Performance about Py<T>

[sun-rs]

#[pyclass]
pub struct Account {
    pub money: i64,
}

#[pymethods]
impl Account {
    pub fn some_acc_func() {}
}

#[pyclass]
pub struct Market {
    pub account: Py<Account>,
}

#[pymethods]
impl Market {
    pub fn some_func() {}
}

pub struct MarketPure {
    pub account: Account,
}

#python
market = Market()
market.call_func()
market.account.call_acc_func()

With pyo3 I could get a class named Account and Market in python, and also do market.call_func() or market.account.call_acc_func().

Py::as_ref, to borrow a GIL-bound reference to the contained object.
Py::borrow, Py::try_borrow, Py::borrow_mut, or Py::try_borrow_mut, to get a (mutable) reference to a contained pyclass, using a scheme similar to std's [RefCell].

What I wonder is that if use the struct Market in rust and call self.account.borrow_mut().some_acc_func(), would it get the same performance like a MarketPure call self.account.some_acc_func()? The gil is no need to concern when [pyclass] is used in rust code?

[messense]

Py::borrow_mut requires you to pass Python<'_> a.k.a the GIL token so when #[pyclass] is used in Rust code GIL is concerned.

Note that when talking about performance, it's always a good idea to actually measure it and provide numbers.

[sun-rs]

have run some test, test multiple borrow_mut in same one Python::with_gil got a similar time cost to pure rust code(3.4us/turn <-> 3.3us/turn). But when test multiple Python::with_gil with borrow_mut it became slower(4.9us/turn <-> 3.3us/turn). It seems check Gil token takes some time.

Because I need to use struct Market both in python and rust, so maybe it's better to set self.account as Account directly and wrap its func to Market rather than call func with Py<Account> borrow_mut, I think this could improve performance in rust side. Is that right?