Why nb_func_vectorcall_simple don't allow None as positional arguments?

[zhqrbitee]

Hi, I notice there is some noticeable performance difference between calling method with positional arguments and kwargs arguments, especially when the method is defined without any nanobind::arg.

For example,

m.def("call1", [](nanobind::handle a, nanobind::handle b) {});
m.def("call2", [](nanobind::handle a, nanobind::handle b) {}, "a"_a, "b"_b); 

call1 is the fastest one, call2 with positional arguments is slower, call2 with kwargs arguments is the slowest one.

I digged in to the codes and it seems call1 will be dispatch to nb_func_vectorcall_simple, as it has no user defined nanobind::arg, call2 is dispatched to nb_func_vectorcall_complex since it can accept kwargs.

However, one thing I don't quite understand is that inside nb_func_vectorcall_simple codes, it says it cannot accept None as positional argument:

static PyObject *nb_func_vectorcall_simple(PyObject *self,
                                           PyObject *const *args_in,
                                           size_t nargsf,
                                           PyObject *kwargs_in) noexcept {
    ...
    bool fail = kwargs_in != nullptr;
    PyObject *none_ptr = Py_None;
    for (size_t i = 0; i < nargs_in; ++i)
        fail |= args_in[i] == none_ptr;

Just curious, is that a specified reason for that?

[wjakob]

nb_func_vectorcall_simple is for the most trival case where arguments can be more or less copied over, and that only works if none of the arguments have annotations. Nanobind has a default policy of not accepting None unless enabled by an annotation. What you describe triggers that special case because a None-accepting argument requires an annotation. In general, I suppose it makes sense that there has to be some threshold between the fast and the complex path, and that's simply where I drew the line. You could likely create your own function object with a custom dispatcher if this bothers you.

[zhqrbitee]

You could likely create your own function object with a custom dispatcher if this bothers you.

@wjakob More hint on this? I'm feeling even with keywords supported (e.g. nanobind::arg or ""_a), we can dispatch to simple call, as long as user uses positional call.

[](PyObject *self, PyObject *const *args_in, size_t nargsf, PyObject *kwargs_in) {
    if (!kwargs_in) [[likely]] {
      // nb_func_vectorcall_simple
    }
    // nb_func_vectorcall_complex;
};

But I'm not sure how to do this: create your own function object with a custom dispatcher with public APIs of nanobind now (I can patch source codes of nanobind and maintain my own version, but this is something I want to avoid).