Improve conversion performance by caching dyn handle on subtype (#243)

Author: qwreey

crates/lune-std-ffi/src/c/c_arr.rs

@@ -1,10 +1,17 @@
+use std::cell::Ref;
+
 use libffi::middle::Type;
 use mlua::prelude::*;
 
-use super::association_names::CARR_INNER;
-use super::c_helper::{get_ensured_size, libffi_type_from_userdata, pretty_format_userdata};
-use super::c_ptr::CPtr;
-use crate::ffi::ffi_association::{get_association, set_association};
+use super::{
+    association_names::CARR_INNER,
+    c_helper::{get_conv, get_ensured_size, libffi_type_from_userdata, pretty_format_userdata},
+    CPtr,
+};
+use crate::ffi::{
+    ffi_association::{get_association, set_association},
+    FfiBox, GetNativeDataHandle, NativeConvert, NativeDataHandle, NativeSignedness, NativeSize,
+};
 
 // This is a series of some type.
 // It provides the final size and the offset of the index,
@@ -18,24 +25,30 @@ use crate::ffi::ffi_association::{get_association, set_association};
 // There is no problem even if you create a struct with n fields of a single type within the struct. Array adheres to the condition that there is no additional padding between each element. Padding to a struct is padding inside the struct. Simply think of the padding byte as a trailing unnamed field.
 
 pub struct CArr {
-    element_type: Type,
+    // element_type: Type,
     struct_type: Type,
     length: usize,
     field_size: usize,
     size: usize,
+    conv: *const dyn NativeConvert,
 }
 
 impl CArr {
-    pub fn new(element_type: Type, length: usize) -> LuaResult<Self> {
-        let struct_type = Type::structure(vec![element_type.clone(); length]);
+    pub fn new(
+        element_type: Type,
+        length: usize,
+        conv: *const dyn NativeConvert,
+    ) -> LuaResult<Self> {
         let field_size = get_ensured_size(element_type.as_raw_ptr())?;
+        let struct_type = Type::structure(vec![element_type.clone(); length]);
 
         Ok(Self {
-            element_type,
+            // element_type,
             struct_type,
             length,
             field_size,
             size: field_size * length,
+            conv,
         })
     }
 
@@ -45,16 +58,13 @@ impl CArr {
         length: usize,
     ) -> LuaResult<LuaAnyUserData<'lua>> {
         let fields = libffi_type_from_userdata(lua, luatype)?;
-        let carr = lua.create_userdata(Self::new(fields, length)?)?;
+        let conv = unsafe { get_conv(luatype)? };
+        let carr = lua.create_userdata(Self::new(fields, length, conv)?)?;
 
         set_association(lua, CARR_INNER, &carr, luatype)?;
         Ok(carr)
     }
 
-    pub fn get_size(&self) -> usize {
-        self.size
-    }
-
     pub fn get_length(&self) -> usize {
         self.length
     }
@@ -63,9 +73,9 @@ impl CArr {
         &self.struct_type
     }
 
-    pub fn get_element_type(&self) -> &Type {
-        &self.element_type
-    }
+    // pub fn get_element_type(&self) -> &Type {
+    //     &self.element_type
+    // }
 
     // Stringify cstruct for pretty printing something like:
     // <CStruct( u8, i32, size = 8 )>
@@ -89,6 +99,64 @@ impl CArr {
     }
 }
 
+impl NativeSize for CArr {
+    fn get_size(&self) -> usize {
+        self.size
+    }
+}
+impl NativeSignedness for CArr {
+    fn get_signedness(&self) -> bool {
+        false
+    }
+}
+impl NativeConvert for CArr {
+    // FIXME: FfiBox, FfiRef support required
+    unsafe fn luavalue_into<'lua>(
+        &self,
+        lua: &'lua Lua,
+        offset: isize,
+        data_handle: &Ref<dyn NativeDataHandle>,
+        value: LuaValue<'lua>,
+    ) -> LuaResult<()> {
+        let LuaValue::Table(ref table) = value else {
+            return Err(LuaError::external("Value is not a table"));
+        };
+        for i in 0..self.length {
+            let field_offset = (i * self.field_size) as isize;
+            let data: LuaValue = table.get(i + 1)?;
+
+            self.conv.as_ref().unwrap().luavalue_into(
+                lua,
+                field_offset + offset,
+                data_handle,
+                data,
+            )?;
+        }
+        Ok(())
+    }
+
+    unsafe fn luavalue_from<'lua>(
+        &self,
+        lua: &'lua Lua,
+        offset: isize,
+        data_handle: &Ref<dyn NativeDataHandle>,
+    ) -> LuaResult<LuaValue<'lua>> {
+        let table = lua.create_table_with_capacity(self.length, 0)?;
+        for i in 0..self.length {
+            let field_offset = (i * self.field_size) as isize;
+            table.set(
+                i + 1,
+                self.conv.as_ref().unwrap().luavalue_from(
+                    lua,
+                    field_offset + offset,
+                    data_handle,
+                )?,
+            )?;
+        }
+        Ok(LuaValue::Table(table))
+    }
+}
+
 impl LuaUserData for CArr {
     fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
         fields.add_field_method_get("size", |_, this| Ok(this.get_size()));
@@ -109,6 +177,44 @@ impl LuaUserData for CArr {
                 Err(LuaError::external("Out of index"))
             }
         });
+        methods.add_method("box", |lua, this, table: LuaValue| {
+            let result = lua.create_userdata(FfiBox::new(this.get_size()))?;
+
+            unsafe { this.luavalue_into(lua, 0, &result.get_data_handle()?, table)? };
+            Ok(result)
+        });
+        methods.add_method(
+            "from",
+            |lua, this, (userdata, offset): (LuaAnyUserData, Option<isize>)| {
+                let offset = offset.unwrap_or(0);
+
+                let data_handle = &userdata.get_data_handle()?;
+                if !data_handle.check_boundary(offset, this.get_size()) {
+                    return Err(LuaError::external("Out of bounds"));
+                }
+                if !data_handle.check_readable(&userdata, offset, this.get_size()) {
+                    return Err(LuaError::external("Unreadable data handle"));
+                }
+
+                unsafe { this.luavalue_from(lua, offset, data_handle) }
+            },
+        );
+        methods.add_method(
+            "into",
+            |lua, this, (userdata, value, offset): (LuaAnyUserData, LuaValue, Option<isize>)| {
+                let offset = offset.unwrap_or(0);
+
+                let data_handle = &userdata.get_data_handle()?;
+                if !data_handle.check_boundary(offset, this.size) {
+                    return Err(LuaError::external("Out of bounds"));
+                }
+                if !data_handle.checek_writable(&userdata, offset, this.size) {
+                    return Err(LuaError::external("Unwritable data handle"));
+                }
+
+                unsafe { this.luavalue_into(lua, offset, data_handle, value) }
+            },
+        );
         methods.add_function("ptr", |lua, this: LuaAnyUserData| {
             let pointer = CPtr::new_from_lua_userdata(lua, &this)?;
             Ok(pointer)

crates/lune-std-ffi/src/c/c_helper.rs

@@ -6,10 +6,9 @@ use libffi::{low, middle::Type, raw};
 use lune_utils::fmt::{pretty_format_value, ValueFormatConfig};
 use mlua::prelude::*;
 
-use super::association_names::CTYPE_STATIC;
-use super::c_type::CTypeStatic;
-use super::types::get_ctype_conv;
-use super::{CArr, CPtr, CStruct};
+use super::{
+    association_names::CTYPE_STATIC, types::get_ctype_conv, CArr, CPtr, CStruct, CTypeStatic,
+};
 use crate::ffi::{ffi_association::get_association, NativeConvert, FFI_STATUS_NAMES};
 
 // Get the NativeConvert handle from the type UserData

crates/lune-std-ffi/src/c/c_type.rs

@@ -88,7 +88,7 @@ impl<T> NativeSize for CType<T> {
     }
 }
 
-pub struct CType<T: ?Sized> {
+pub struct CType<T> {
     // for ffi_ptrarray_to_raw?
     // libffi_cif: Cif,
     libffi_type: Type,

crates/lune-std-ffi/src/c/mod.rs

@@ -12,7 +12,7 @@ pub use self::{
     c_fn::CFn,
     c_ptr::CPtr,
     c_struct::CStruct,
-    c_type::{CType, CTypeCast},
+    c_type::{CType, CTypeCast, CTypeStatic},
 };
 
 pub use types::create_all_c_types;