Repeated inheritance, trampoline, and instance lookup / inst_c2p.

[WKarel]

The following example binds the base class Pet, and a derived class Dog with a pure virtual function - hence using the trampoline/alias class PyDog.

Derivation from Dog in Python and overriding the virtual function work fine.

The functions dogPassThrough and petPassThrough simply return their only argument, using none as return value policy (since the original PyObject surely exists at this point). This works if the argument's static type is Dog, but if fails for Pet.

Is there any way to make petPassThrough return its argument to Python without creating a new instance? Making petPassThrough expect a Python handle would not help me, because my application does not return arguments directly, but stores and returns them in/from a third-party library, using keep_alive to ensure that Python instances still exist when their C++ counterparts shall be returned.

I am delighted by the run-time speed of nanobind. But being unable to return the original Python instances in this case would be a show stopper for me. So I'd be grateful for any advices.

Having created an instance of that class derived in Python, nanobind's instance map inst_c2p holds a single element for that instance. That element's key is the combination of the address of the C++ part, and its non-trampoline-type i.e. Dog. If the static argument type is Dog, then nb_type_put_p succeeds to find the instance, of course. But not if it is a base class thereof. Note that the combination for the dynamic type PyDog is looked up, but not registered.

Since it seems like a promising solution, and out of curiosity: why does inst_c2p not only use an address as key, but a combination of address and type_info?

C++ code:

#include <nanobind/nanobind.h>
#include <nanobind/trampoline.h>
#include <nanobind/stl/string.h>

struct Pet
{
  virtual ~Pet() = default;
};

struct Dog : Pet
{
  virtual std::string bark() const = 0;
};

struct PyDog : Dog
{
  NB_TRAMPOLINE(Dog, 1);

  std::string bark() const override
  {
    NB_OVERRIDE_PURE(bark);
  }
};

NB_MODULE(nanobind_test, m)
{
  namespace nb = nanobind;

  nb::class_<Pet>(m, "Pet");

  nb::class_<Dog, PyDog, Pet>(m, "Dog")
    .def(nb::init())
    .def("bark", &Dog::bark) ;

  m.def("alarm", [](Dog& dog)
    {
      dog.bark();
    });

  m.def("dogPassThrough", [](Dog* dog)
    {
      return dog;
    }, nb::rv_policy::none);

  m.def("petPassThrough", [](Pet* pet)
    {
      return pet;
    }, nb::rv_policy::none);
}

Python code:

import nanobind_test

class ShihTzu(nanobind_test.Dog):
    def bark(self):
        return "yip!"
        
dog = ShihTzu()
nanobind_test.alarm(dog)

nanobind_test.dogPassThrough(dog)
# fails:
nanobind_test.petPassThrough(dog)

[wjakob]

Since it seems like a promising solution, and out of curiosity: why does inst_c2p not only use an address as key, but a combination of address and type_info?

The reason is that you can have multiple instances with the same pointer address but different types. For example:

struct Foo {
    Bar b1;
    Bar b2;
};
Foo f;

Nanobind must be able to simultaneously access f and its members using different types. But f and f.b1 actually have the same address.
Out of curiosity: have you tried this in pybind11? I am wondering if the same issue is present there. (it does not have the none return value policy, but it should be possible to use the is comparison to check if a copy/new instance is made)

[wjakob]

Resolved via 716354f.

[WKarel]

Wow, what an efficient solution!
And my seemingly naive question even made it into the core data structures 😄
Yes, this also works with pybind11.
Thanks a lot!