mirror of
https://github.com/denoland/deno.git
synced 2024-12-26 09:10:40 -05:00
702284dc22
This commit changes "eager ops" to directly return a response value instead of calling "opresponse" callback in JavaScript. This saves one boundary crossing and has a fantastic impact on the "async_ops.js" benchmark: ``` v1.32.4 $ deno run cli/bench/async_ops.js time 329 ms rate 3039513 time 322 ms rate 3105590 time 307 ms rate 3257328 time 301 ms rate 3322259 time 303 ms rate 3300330 time 306 ms rate 3267973 time 300 ms rate 3333333 time 301 ms rate 3322259 time 301 ms rate 3322259 time 301 ms rate 3322259 time 302 ms rate 3311258 time 301 ms rate 3322259 time 302 ms rate 3311258 time 302 ms rate 3311258 time 303 ms rate 3300330 ``` ``` this branch $ ./target/release/deno run -A cli/bench/async_ops.js time 257 ms rate 3891050 time 248 ms rate 4032258 time 251 ms rate 3984063 time 246 ms rate 4065040 time 238 ms rate 4201680 time 227 ms rate 4405286 time 228 ms rate 4385964 time 229 ms rate 4366812 time 228 ms rate 4385964 time 226 ms rate 4424778 time 226 ms rate 4424778 time 227 ms rate 4405286 time 228 ms rate 4385964 time 227 ms rate 4405286 time 228 ms rate 4385964 time 227 ms rate 4405286 time 229 ms rate 4366812 time 228 ms rate 4385964 ``` Prerequisite for https://github.com/denoland/deno/pull/18652
1004 lines
30 KiB
Rust
1004 lines
30 KiB
Rust
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
|
//! Optimizer for #[op]
|
|
|
|
use std::collections::BTreeMap;
|
|
use std::fmt::Debug;
|
|
use std::fmt::Formatter;
|
|
|
|
use pmutil::q;
|
|
use pmutil::Quote;
|
|
use proc_macro2::TokenStream;
|
|
|
|
use syn::parse_quote;
|
|
use syn::punctuated::Punctuated;
|
|
use syn::token::Colon2;
|
|
use syn::AngleBracketedGenericArguments;
|
|
use syn::FnArg;
|
|
use syn::GenericArgument;
|
|
use syn::PatType;
|
|
use syn::Path;
|
|
use syn::PathArguments;
|
|
use syn::PathSegment;
|
|
use syn::ReturnType;
|
|
use syn::Signature;
|
|
use syn::Type;
|
|
use syn::TypePath;
|
|
use syn::TypePtr;
|
|
use syn::TypeReference;
|
|
use syn::TypeSlice;
|
|
use syn::TypeTuple;
|
|
|
|
use crate::Op;
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) enum BailoutReason {
|
|
// Recoverable errors
|
|
MustBeSingleSegment,
|
|
FastUnsupportedParamType,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
enum StringType {
|
|
Cow,
|
|
Ref,
|
|
Owned,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
enum TransformKind {
|
|
// serde_v8::Value
|
|
V8Value,
|
|
SliceU32(bool),
|
|
SliceU8(bool),
|
|
SliceF64(bool),
|
|
SeqOneByteString(StringType),
|
|
PtrU8,
|
|
PtrVoid,
|
|
WasmMemory,
|
|
}
|
|
|
|
impl Transform {
|
|
fn serde_v8_value(index: usize) -> Self {
|
|
Transform {
|
|
kind: TransformKind::V8Value,
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn slice_u32(index: usize, is_mut: bool) -> Self {
|
|
Transform {
|
|
kind: TransformKind::SliceU32(is_mut),
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn slice_u8(index: usize, is_mut: bool) -> Self {
|
|
Transform {
|
|
kind: TransformKind::SliceU8(is_mut),
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn slice_f64(index: usize, is_mut: bool) -> Self {
|
|
Transform {
|
|
kind: TransformKind::SliceF64(is_mut),
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn seq_one_byte_string(index: usize, is_ref: StringType) -> Self {
|
|
Transform {
|
|
kind: TransformKind::SeqOneByteString(is_ref),
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn wasm_memory(index: usize) -> Self {
|
|
Transform {
|
|
kind: TransformKind::WasmMemory,
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn u8_ptr(index: usize) -> Self {
|
|
Transform {
|
|
kind: TransformKind::PtrU8,
|
|
index,
|
|
}
|
|
}
|
|
|
|
fn void_ptr(index: usize) -> Self {
|
|
Transform {
|
|
kind: TransformKind::PtrVoid,
|
|
index,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub(crate) struct Transform {
|
|
kind: TransformKind,
|
|
index: usize,
|
|
}
|
|
|
|
impl Transform {
|
|
pub(crate) fn apply_for_fast_call(
|
|
&self,
|
|
core: &TokenStream,
|
|
input: &mut FnArg,
|
|
) -> Quote {
|
|
let (ty, ident) = match input {
|
|
FnArg::Typed(PatType {
|
|
ref mut ty,
|
|
ref pat,
|
|
..
|
|
}) => {
|
|
let ident = match &**pat {
|
|
syn::Pat::Ident(ident) => &ident.ident,
|
|
_ => unreachable!("error not recovered"),
|
|
};
|
|
(ty, ident)
|
|
}
|
|
_ => unreachable!("error not recovered"),
|
|
};
|
|
|
|
match &self.kind {
|
|
// serde_v8::Value
|
|
TransformKind::V8Value => {
|
|
*ty = parse_quote! { #core::v8::Local<v8::Value> };
|
|
|
|
q!(Vars { var: &ident }, {
|
|
let var = serde_v8::Value { v8_value: var };
|
|
})
|
|
}
|
|
// &[u32]
|
|
TransformKind::SliceU32(_) => {
|
|
*ty =
|
|
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u32> };
|
|
|
|
q!(Vars { var: &ident }, {
|
|
// V8 guarantees that ArrayBuffers are always 4-byte aligned
|
|
// (seems to be always 8-byte aligned on 64-bit machines)
|
|
// but Deno FFI makes it possible to create ArrayBuffers at any
|
|
// alignment. Thus this check is needed.
|
|
let var = match unsafe { &*var }.get_storage_if_aligned() {
|
|
Some(v) => v,
|
|
None => {
|
|
unsafe { &mut *fast_api_callback_options }.fallback = true;
|
|
return Default::default();
|
|
}
|
|
};
|
|
})
|
|
}
|
|
// &[u8]
|
|
TransformKind::SliceU8(_) => {
|
|
*ty =
|
|
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u8> };
|
|
|
|
q!(Vars { var: &ident }, {
|
|
// SAFETY: U8 slice is always byte-aligned.
|
|
let var =
|
|
unsafe { (&*var).get_storage_if_aligned().unwrap_unchecked() };
|
|
})
|
|
}
|
|
TransformKind::SliceF64(_) => {
|
|
*ty =
|
|
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<f64> };
|
|
|
|
q!(Vars { var: &ident }, {
|
|
let var = match unsafe { &*var }.get_storage_if_aligned() {
|
|
Some(v) => v,
|
|
None => {
|
|
unsafe { &mut *fast_api_callback_options }.fallback = true;
|
|
return Default::default();
|
|
}
|
|
};
|
|
})
|
|
}
|
|
// &str
|
|
TransformKind::SeqOneByteString(str_ty) => {
|
|
*ty = parse_quote! { *const #core::v8::fast_api::FastApiOneByteString };
|
|
match str_ty {
|
|
StringType::Ref => q!(Vars { var: &ident }, {
|
|
let var = match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
|
|
Ok(v) => v,
|
|
Err(_) => {
|
|
unsafe { &mut *fast_api_callback_options }.fallback = true;
|
|
return Default::default();
|
|
}
|
|
};
|
|
}),
|
|
StringType::Cow => q!(Vars { var: &ident }, {
|
|
let var = ::std::borrow::Cow::Borrowed(
|
|
match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
|
|
Ok(v) => v,
|
|
Err(_) => {
|
|
unsafe { &mut *fast_api_callback_options }.fallback = true;
|
|
return Default::default();
|
|
}
|
|
},
|
|
);
|
|
}),
|
|
StringType::Owned => q!(Vars { var: &ident }, {
|
|
let var = match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
|
|
Ok(v) => v.to_owned(),
|
|
Err(_) => {
|
|
unsafe { &mut *fast_api_callback_options }.fallback = true;
|
|
return Default::default();
|
|
}
|
|
};
|
|
}),
|
|
}
|
|
}
|
|
TransformKind::WasmMemory => {
|
|
// Note: `ty` is correctly set to __opts by the fast call tier.
|
|
// U8 slice is always byte-aligned.
|
|
q!(Vars { var: &ident, core }, {
|
|
let var = unsafe {
|
|
&*(__opts.wasm_memory
|
|
as *const core::v8::fast_api::FastApiTypedArray<u8>)
|
|
}
|
|
.get_storage_if_aligned();
|
|
})
|
|
}
|
|
// *const u8
|
|
TransformKind::PtrU8 => {
|
|
*ty =
|
|
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u8> };
|
|
|
|
q!(Vars { var: &ident }, {
|
|
// SAFETY: U8 slice is always byte-aligned.
|
|
let var =
|
|
unsafe { (&*var).get_storage_if_aligned().unwrap_unchecked() }
|
|
.as_ptr();
|
|
})
|
|
}
|
|
TransformKind::PtrVoid => {
|
|
*ty = parse_quote! { *mut ::std::ffi::c_void };
|
|
|
|
q!(Vars {}, {})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_fast_scalar(s: &str) -> Option<FastValue> {
|
|
match s {
|
|
"bool" => Some(FastValue::Bool),
|
|
"u32" => Some(FastValue::U32),
|
|
"i32" => Some(FastValue::I32),
|
|
"u64" | "usize" => Some(FastValue::U64),
|
|
"i64" | "isize" => Some(FastValue::I64),
|
|
"f32" => Some(FastValue::F32),
|
|
"f64" => Some(FastValue::F64),
|
|
"* const c_void" | "* mut c_void" => Some(FastValue::Pointer),
|
|
"ResourceId" => Some(FastValue::U32),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn can_return_fast(v: &FastValue) -> bool {
|
|
!matches!(
|
|
v,
|
|
FastValue::U64
|
|
| FastValue::I64
|
|
| FastValue::Uint8Array
|
|
| FastValue::Uint32Array
|
|
)
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub(crate) enum FastValue {
|
|
Void,
|
|
Bool,
|
|
U32,
|
|
I32,
|
|
U64,
|
|
I64,
|
|
F32,
|
|
F64,
|
|
Pointer,
|
|
V8Value,
|
|
Uint8Array,
|
|
Uint32Array,
|
|
Float64Array,
|
|
SeqOneByteString,
|
|
}
|
|
|
|
impl FastValue {
|
|
pub fn default_value(&self) -> Quote {
|
|
match self {
|
|
FastValue::Pointer => q!({ ::std::ptr::null_mut() }),
|
|
FastValue::Void => q!({}),
|
|
_ => q!({ Default::default() }),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for FastValue {
|
|
fn default() -> Self {
|
|
Self::Void
|
|
}
|
|
}
|
|
|
|
#[derive(Default, PartialEq)]
|
|
pub(crate) struct Optimizer {
|
|
pub(crate) returns_result: bool,
|
|
|
|
pub(crate) has_ref_opstate: bool,
|
|
|
|
pub(crate) has_rc_opstate: bool,
|
|
|
|
// Do we need an explict FastApiCallbackOptions argument?
|
|
pub(crate) has_fast_callback_option: bool,
|
|
// Do we depend on FastApiCallbackOptions?
|
|
pub(crate) needs_fast_callback_option: bool,
|
|
|
|
pub(crate) has_wasm_memory: bool,
|
|
|
|
pub(crate) fast_result: Option<FastValue>,
|
|
pub(crate) fast_parameters: Vec<FastValue>,
|
|
|
|
pub(crate) transforms: BTreeMap<usize, Transform>,
|
|
pub(crate) fast_compatible: bool,
|
|
|
|
pub(crate) is_async: bool,
|
|
}
|
|
|
|
impl Debug for Optimizer {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
writeln!(f, "=== Optimizer Dump ===")?;
|
|
writeln!(f, "returns_result: {}", self.returns_result)?;
|
|
writeln!(f, "has_ref_opstate: {}", self.has_ref_opstate)?;
|
|
writeln!(f, "has_rc_opstate: {}", self.has_rc_opstate)?;
|
|
writeln!(
|
|
f,
|
|
"has_fast_callback_option: {}",
|
|
self.has_fast_callback_option
|
|
)?;
|
|
writeln!(
|
|
f,
|
|
"needs_fast_callback_option: {}",
|
|
self.needs_fast_callback_option
|
|
)?;
|
|
writeln!(f, "fast_result: {:?}", self.fast_result)?;
|
|
writeln!(f, "fast_parameters: {:?}", self.fast_parameters)?;
|
|
writeln!(f, "transforms: {:?}", self.transforms)?;
|
|
writeln!(f, "is_async: {}", self.is_async)?;
|
|
writeln!(f, "fast_compatible: {}", self.fast_compatible)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Optimizer {
|
|
pub(crate) fn new() -> Self {
|
|
Default::default()
|
|
}
|
|
|
|
pub(crate) const fn has_opstate_in_parameters(&self) -> bool {
|
|
self.has_ref_opstate || self.has_rc_opstate
|
|
}
|
|
|
|
pub(crate) const fn needs_opstate(&self) -> bool {
|
|
self.has_ref_opstate || self.has_rc_opstate || self.returns_result
|
|
}
|
|
|
|
pub(crate) fn analyze(&mut self, op: &mut Op) -> Result<(), BailoutReason> {
|
|
// Fast async ops are opt-in as they have a lazy polling behavior.
|
|
if op.is_async && !op.attrs.must_be_fast {
|
|
self.fast_compatible = false;
|
|
return Ok(());
|
|
}
|
|
|
|
if op.attrs.is_v8 {
|
|
self.fast_compatible = false;
|
|
return Ok(());
|
|
}
|
|
|
|
self.is_async = op.is_async;
|
|
self.fast_compatible = true;
|
|
// Just assume for now. We will validate later.
|
|
self.has_wasm_memory = op.attrs.is_wasm;
|
|
|
|
let sig = &op.item.sig;
|
|
|
|
// Analyze return type
|
|
match &sig {
|
|
Signature {
|
|
output: ReturnType::Default,
|
|
..
|
|
} => self.fast_result = Some(FastValue::default()),
|
|
Signature {
|
|
output: ReturnType::Type(_, ty),
|
|
..
|
|
} if !self.is_async => self.analyze_return_type(ty)?,
|
|
|
|
// No need to error on the return type for async ops, its OK if
|
|
// it's not a fast value.
|
|
Signature {
|
|
output: ReturnType::Type(_, ty),
|
|
..
|
|
} => {
|
|
let _ = self.analyze_return_type(ty);
|
|
// Recover.
|
|
self.fast_result = None;
|
|
self.fast_compatible = true;
|
|
}
|
|
};
|
|
|
|
// The reciever, which we don't actually care about.
|
|
self.fast_parameters.push(FastValue::V8Value);
|
|
|
|
if self.is_async {
|
|
// The promise ID.
|
|
self.fast_parameters.push(FastValue::I32);
|
|
}
|
|
|
|
// Analyze parameters
|
|
for (index, param) in sig.inputs.iter().enumerate() {
|
|
self.analyze_param_type(index, param)?;
|
|
}
|
|
|
|
// TODO(@littledivy): https://github.com/denoland/deno/issues/17159
|
|
if self.returns_result
|
|
&& self.fast_parameters.contains(&FastValue::SeqOneByteString)
|
|
{
|
|
self.fast_compatible = false;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn analyze_return_type(&mut self, ty: &Type) -> Result<(), BailoutReason> {
|
|
match ty {
|
|
Type::Tuple(TypeTuple { elems, .. }) if elems.is_empty() => {
|
|
self.fast_result = Some(FastValue::Void);
|
|
}
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
let segment = single_segment(segments)?;
|
|
|
|
match segment {
|
|
// Result<T, E>
|
|
PathSegment {
|
|
ident, arguments, ..
|
|
} if ident == "Result" => {
|
|
self.returns_result = true;
|
|
|
|
if let PathArguments::AngleBracketed(
|
|
AngleBracketedGenericArguments { args, .. },
|
|
) = arguments
|
|
{
|
|
match args.first() {
|
|
Some(GenericArgument::Type(Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}))) => {
|
|
let PathSegment { ident, .. } = single_segment(segments)?;
|
|
// Is `T` a scalar FastValue?
|
|
if let Some(val) = get_fast_scalar(ident.to_string().as_str())
|
|
{
|
|
if can_return_fast(&val) {
|
|
self.fast_result = Some(val);
|
|
return Ok(());
|
|
}
|
|
}
|
|
|
|
self.fast_compatible = false;
|
|
return Err(BailoutReason::FastUnsupportedParamType);
|
|
}
|
|
Some(GenericArgument::Type(Type::Tuple(TypeTuple {
|
|
elems,
|
|
..
|
|
})))
|
|
if elems.is_empty() =>
|
|
{
|
|
self.fast_result = Some(FastValue::Void);
|
|
}
|
|
Some(GenericArgument::Type(Type::Ptr(TypePtr {
|
|
mutability: Some(_),
|
|
elem,
|
|
..
|
|
}))) => {
|
|
match &**elem {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
// Is `T` a c_void?
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
PathSegment { ident, .. } if ident == "c_void" => {
|
|
self.fast_result = Some(FastValue::Pointer);
|
|
return Ok(());
|
|
}
|
|
_ => {
|
|
return Err(BailoutReason::FastUnsupportedParamType)
|
|
}
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
}
|
|
// Is `T` a scalar FastValue?
|
|
PathSegment { ident, .. } => {
|
|
if let Some(val) = get_fast_scalar(ident.to_string().as_str()) {
|
|
self.fast_result = Some(val);
|
|
return Ok(());
|
|
}
|
|
|
|
self.fast_compatible = false;
|
|
return Err(BailoutReason::FastUnsupportedParamType);
|
|
}
|
|
};
|
|
}
|
|
Type::Ptr(TypePtr {
|
|
mutability: Some(_),
|
|
elem,
|
|
..
|
|
}) => {
|
|
match &**elem {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
// Is `T` a c_void?
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
PathSegment { ident, .. } if ident == "c_void" => {
|
|
self.fast_result = Some(FastValue::Pointer);
|
|
return Ok(());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
};
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn analyze_param_type(
|
|
&mut self,
|
|
index: usize,
|
|
arg: &FnArg,
|
|
) -> Result<(), BailoutReason> {
|
|
match arg {
|
|
FnArg::Typed(typed) => match &*typed.ty {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) if segments.len() == 2 => {
|
|
match double_segment(segments)? {
|
|
// -> serde_v8::Value
|
|
[PathSegment { ident: first, .. }, PathSegment { ident: last, .. }]
|
|
if first == "serde_v8" && last == "Value" =>
|
|
{
|
|
self.fast_parameters.push(FastValue::V8Value);
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::serde_v8_value(index))
|
|
.is_none());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
let segment = single_segment(segments)?;
|
|
|
|
match segment {
|
|
// -> Option<T>
|
|
PathSegment {
|
|
ident, arguments, ..
|
|
} if ident == "Option" => {
|
|
if let PathArguments::AngleBracketed(
|
|
AngleBracketedGenericArguments { args, .. },
|
|
) = arguments
|
|
{
|
|
// -> Option<&mut T>
|
|
if let Some(GenericArgument::Type(Type::Reference(
|
|
TypeReference { elem, .. },
|
|
))) = args.last()
|
|
{
|
|
if self.has_wasm_memory {
|
|
// -> Option<&mut [u8]>
|
|
if let Type::Slice(TypeSlice { elem, .. }) = &**elem {
|
|
if let Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) = &**elem
|
|
{
|
|
let segment = single_segment(segments)?;
|
|
|
|
match segment {
|
|
// Is `T` a u8?
|
|
PathSegment { ident, .. } if ident == "u8" => {
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::wasm_memory(index))
|
|
.is_none());
|
|
}
|
|
_ => {
|
|
return Err(BailoutReason::FastUnsupportedParamType)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if let Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) = &**elem
|
|
{
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
// Is `T` a FastApiCallbackOptions?
|
|
PathSegment { ident, .. }
|
|
if ident == "FastApiCallbackOptions" =>
|
|
{
|
|
self.has_fast_callback_option = true;
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
} else {
|
|
return Err(BailoutReason::FastUnsupportedParamType);
|
|
}
|
|
} else {
|
|
return Err(BailoutReason::FastUnsupportedParamType);
|
|
}
|
|
}
|
|
}
|
|
// -> Rc<T>
|
|
PathSegment {
|
|
ident, arguments, ..
|
|
} if ident == "Rc" => {
|
|
if let PathArguments::AngleBracketed(
|
|
AngleBracketedGenericArguments { args, .. },
|
|
) = arguments
|
|
{
|
|
match args.last() {
|
|
Some(GenericArgument::Type(Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}))) => {
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
// -> Rc<RefCell<T>>
|
|
PathSegment {
|
|
ident, arguments, ..
|
|
} if ident == "RefCell" => {
|
|
if let PathArguments::AngleBracketed(
|
|
AngleBracketedGenericArguments { args, .. },
|
|
) = arguments
|
|
{
|
|
match args.last() {
|
|
// -> Rc<RefCell<OpState>>
|
|
Some(GenericArgument::Type(Type::Path(
|
|
TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
},
|
|
))) => {
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
PathSegment { ident, .. }
|
|
if ident == "OpState" =>
|
|
{
|
|
self.has_rc_opstate = true;
|
|
}
|
|
_ => {
|
|
return Err(
|
|
BailoutReason::FastUnsupportedParamType,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
return Err(
|
|
BailoutReason::FastUnsupportedParamType,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
}
|
|
// Cow<'_, str>
|
|
PathSegment {
|
|
ident, arguments, ..
|
|
} if ident == "Cow" => {
|
|
if let PathArguments::AngleBracketed(
|
|
AngleBracketedGenericArguments { args, .. },
|
|
) = arguments
|
|
{
|
|
assert_eq!(args.len(), 2);
|
|
|
|
let ty = &args[1];
|
|
match ty {
|
|
GenericArgument::Type(Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
})) => {
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
PathSegment { ident, .. } if ident == "str" => {
|
|
self.needs_fast_callback_option = true;
|
|
self.fast_parameters.push(FastValue::SeqOneByteString);
|
|
assert!(self
|
|
.transforms
|
|
.insert(
|
|
index,
|
|
Transform::seq_one_byte_string(
|
|
index,
|
|
StringType::Cow
|
|
)
|
|
)
|
|
.is_none());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
}
|
|
// Is `T` a fast scalar?
|
|
PathSegment { ident, .. } => {
|
|
if let Some(val) = get_fast_scalar(ident.to_string().as_str()) {
|
|
self.fast_parameters.push(val);
|
|
} else if ident == "String" {
|
|
self.needs_fast_callback_option = true;
|
|
// Is `T` an owned String?
|
|
self.fast_parameters.push(FastValue::SeqOneByteString);
|
|
assert!(self
|
|
.transforms
|
|
.insert(
|
|
index,
|
|
Transform::seq_one_byte_string(index, StringType::Owned)
|
|
)
|
|
.is_none());
|
|
} else {
|
|
return Err(BailoutReason::FastUnsupportedParamType);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
// &mut T
|
|
Type::Reference(TypeReference {
|
|
elem, mutability, ..
|
|
}) => match &**elem {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
// Is `T` a OpState?
|
|
PathSegment { ident, .. }
|
|
if ident == "OpState" && !self.is_async =>
|
|
{
|
|
self.has_ref_opstate = true;
|
|
}
|
|
// Is `T` a str?
|
|
PathSegment { ident, .. } if ident == "str" => {
|
|
self.needs_fast_callback_option = true;
|
|
self.fast_parameters.push(FastValue::SeqOneByteString);
|
|
assert!(self
|
|
.transforms
|
|
.insert(
|
|
index,
|
|
Transform::seq_one_byte_string(index, StringType::Ref)
|
|
)
|
|
.is_none());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
// &mut [T]
|
|
Type::Slice(TypeSlice { elem, .. }) => match &**elem {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
let segment = single_segment(segments)?;
|
|
let is_mut_ref = mutability.is_some();
|
|
match segment {
|
|
// Is `T` a u8?
|
|
PathSegment { ident, .. } if ident == "u8" => {
|
|
self.fast_parameters.push(FastValue::Uint8Array);
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::slice_u8(index, is_mut_ref))
|
|
.is_none());
|
|
}
|
|
// Is `T` a u32?
|
|
PathSegment { ident, .. } if ident == "u32" => {
|
|
self.needs_fast_callback_option = true;
|
|
self.fast_parameters.push(FastValue::Uint32Array);
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::slice_u32(index, is_mut_ref))
|
|
.is_none());
|
|
}
|
|
// Is `T` a f64?
|
|
PathSegment { ident, .. } if ident == "f64" => {
|
|
self.needs_fast_callback_option = true;
|
|
self.fast_parameters.push(FastValue::Float64Array);
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::slice_f64(index, is_mut_ref))
|
|
.is_none());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
},
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
},
|
|
// *const T
|
|
Type::Ptr(TypePtr {
|
|
elem,
|
|
const_token: Some(_),
|
|
..
|
|
}) => match &**elem {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
// Is `T` a u8?
|
|
PathSegment { ident, .. } if ident == "u8" => {
|
|
self.fast_parameters.push(FastValue::Uint8Array);
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::u8_ptr(index))
|
|
.is_none());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
},
|
|
// *const T
|
|
Type::Ptr(TypePtr {
|
|
elem,
|
|
mutability: Some(_),
|
|
..
|
|
}) => match &**elem {
|
|
Type::Path(TypePath {
|
|
path: Path { segments, .. },
|
|
..
|
|
}) => {
|
|
let segment = single_segment(segments)?;
|
|
match segment {
|
|
// Is `T` a c_void?
|
|
PathSegment { ident, .. } if ident == "c_void" => {
|
|
self.fast_parameters.push(FastValue::Pointer);
|
|
assert!(self
|
|
.transforms
|
|
.insert(index, Transform::void_ptr(index))
|
|
.is_none());
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
}
|
|
}
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
},
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
},
|
|
_ => return Err(BailoutReason::FastUnsupportedParamType),
|
|
};
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn single_segment(
|
|
segments: &Punctuated<PathSegment, Colon2>,
|
|
) -> Result<&PathSegment, BailoutReason> {
|
|
if segments.len() != 1 {
|
|
return Err(BailoutReason::MustBeSingleSegment);
|
|
}
|
|
|
|
match segments.last() {
|
|
Some(segment) => Ok(segment),
|
|
None => Err(BailoutReason::MustBeSingleSegment),
|
|
}
|
|
}
|
|
|
|
fn double_segment(
|
|
segments: &Punctuated<PathSegment, Colon2>,
|
|
) -> Result<[&PathSegment; 2], BailoutReason> {
|
|
match (segments.first(), segments.last()) {
|
|
(Some(first), Some(last)) => Ok([first, last]),
|
|
// Caller ensures that there are only two segments.
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::Attributes;
|
|
use crate::Op;
|
|
use pretty_assertions::assert_eq;
|
|
use std::path::PathBuf;
|
|
use syn::parse_quote;
|
|
|
|
#[test]
|
|
fn test_single_segment() {
|
|
let segments = parse_quote!(foo);
|
|
assert!(single_segment(&segments).is_ok());
|
|
|
|
let segments = parse_quote!(foo::bar);
|
|
assert!(single_segment(&segments).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_double_segment() {
|
|
let segments = parse_quote!(foo::bar);
|
|
assert!(double_segment(&segments).is_ok());
|
|
assert_eq!(double_segment(&segments).unwrap()[0].ident, "foo");
|
|
assert_eq!(double_segment(&segments).unwrap()[1].ident, "bar");
|
|
}
|
|
|
|
#[testing_macros::fixture("optimizer_tests/**/*.rs")]
|
|
fn test_analyzer(input: PathBuf) {
|
|
let update_expected = std::env::var("UPDATE_EXPECTED").is_ok();
|
|
|
|
let source =
|
|
std::fs::read_to_string(&input).expect("Failed to read test file");
|
|
let expected = std::fs::read_to_string(input.with_extension("expected"))
|
|
.expect("Failed to read expected file");
|
|
|
|
let mut attrs = Attributes::default();
|
|
if source.contains("// @test-attr:wasm") {
|
|
attrs.must_be_fast = true;
|
|
attrs.is_wasm = true;
|
|
}
|
|
if source.contains("// @test-attr:fast") {
|
|
attrs.must_be_fast = true;
|
|
}
|
|
|
|
let item = syn::parse_str(&source).expect("Failed to parse test file");
|
|
let mut op = Op::new(item, attrs);
|
|
let mut optimizer = Optimizer::new();
|
|
if let Err(e) = optimizer.analyze(&mut op) {
|
|
let e_str = format!("{e:?}");
|
|
if update_expected {
|
|
std::fs::write(input.with_extension("expected"), e_str)
|
|
.expect("Failed to write expected file");
|
|
} else {
|
|
assert_eq!(e_str, expected);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if update_expected {
|
|
std::fs::write(
|
|
input.with_extension("expected"),
|
|
format!("{optimizer:#?}"),
|
|
)
|
|
.expect("Failed to write expected file");
|
|
} else {
|
|
assert_eq!(format!("{optimizer:#?}"), expected);
|
|
}
|
|
}
|
|
}
|