What is the fastest way to get a type identifier in pyo3

[ritchie46]

In polars we are getting compute bound on conversion from python values to polars' AnyValue types. Currently the implementation is relatively naive.

impl<'s> FromPyObject<'s> for Wrap<AnyValue<'s>> {
    fn extract(ob: &'s PyAny) -> PyResult<Self> {
        if ob.is_instance_of::<PyBool>()? {
            Ok(AnyValue::Boolean(ob.extract::<bool>().unwrap()).into())
        } else if let Ok(value) = ob.extract::<i64>() {
            Ok(AnyValue::Int64(value).into())
        } else if ob.is_instance_of::<PyFloat>()? {
            let value = ob.extract::<f64>().unwrap();
            Ok(AnyValue::Float64(value).into())
        } else if ob.is_instance_of::<PyString>()? {
            let value = ob.extract::<&'s str>().unwrap();
            Ok(AnyValue::Utf8(value).into())
        } else if ob.is_none() {
            Ok(AnyValue::Null.into())
        } else if ob.is_instance_of::<PyDict>()? {

...

e.g. we are just branching on the isinstance. So I have got a few questions.

1. Is is_instance the fastest way to get type information, or would something like type_id be better/ cheaper?
2. Is there a cheap way to get a UUID so we might be able to construct a lookup table?

I'd love to hear from you, thanks!

[adamreichold]

Maybe you could use PyTypeInfo::type_object_raw to construct a LUT like HashMap<*mut PyTypeObject, fn(&PyAny) -> AnyValue>? Not sure if this will end up being faster but it should cover is_instance_of chains (probably also is_none via _PyNone_Type). Note that you'd need to lazily initialize that LUT using e.g. GILOnceCell.

[ritchie46]

Thanks, I will give that a try.

[kngwyu]

But I guess that if we use only type_object_raw, inheritance and the number slot would not be handled.
Maybe a possible approach is:

1. Prepare an object table (like HashMap<*mut PyTypeObject...)
2. Check if the given object type is in the reconstructed table
3. Check if the ancestors of the type is in the table (to handle inheritance)
4. Checking the number slot (to handle the number slot)

[adamreichold]

Ideally you would even memoize this, e.g. after having looked up the ancestor, store the type itself having the LUT within GILOnceCell<RefCell<HashMap<*mut PyTypeObject, fn(..)>>>:

1. Prepare a list with the well-known type objects and conversion functions for PyString, PyFloat, etc.
2. Use this list to initialize the LUT for look-ups by type object pointer. (Better to use type_object than type_object_raw. The latter is readily available via PyType::as_type_ptr.)
3. Check if the given object is in the LUT and call the conversion if so.
4. If not, enumerate the fundamental list and check for ancestors using PyType::is_subclass
5. If one is found, add the conversion function to the LUT under the descendants type object.

This way means that your table will slowly grow to handle the subclasses you have seen so far. Limiting that growth might also be necessary though. Theoretically, a full blown LRU cache might be an option but I suspect it would be too expensive if this is a hot path already.