C++ method behavior changes through nanobind

[tbridel]

Hi everyone, hi @wjakob !

I hope everyone is well.
I am coming here because I am completely stuck with a behavior that I do not understand.

I am working on a C++ code with a Python wrapper - so far, with nanobind documentation, I managed to link everything as I wanted and everything runs as expected.
Now, I need to add VTK capabilities to the C++ code ... and I cannot make it work.

---

For reference, I downloaded the VTK 9.2.6 tarball from here, and I did not personalize the install at all but just ran mkdir build && cd build && cmake .. && make -j8.

---

I downloaded the FindAllArrayNames example from VTK website - see here. Since the code is small, and for reference, I'll copy-paste it here :

#include <vtkCellData.h>
#include <vtkNew.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
#include <vtkXMLPolyDataReader.h>
#include <vtkXMLPolyDataWriter.h>

#include <string>
#include <vector>

namespace {
void FindAllData(vtkPolyData* polydata);
}

int main(int argc, char* argv[])
{
  vtkSmartPointer<vtkPolyData> polydata;

  vtkNew<vtkXMLPolyDataReader> reader;
  reader->SetFileName(argv[1]);
  reader->Update();
  polydata = reader->GetOutput();
 
  FindAllData(polydata);

  return EXIT_SUCCESS;
}

namespace {
void FindAllData(vtkPolyData* polydata)
{
  std::cout << "Normals: " << polydata->GetPointData()->GetNormals()
            << std::endl;

  vtkIdType numberOfPointArrays = polydata->GetPointData()->GetNumberOfArrays();
  std::cout << "Number of PointData arrays: " << numberOfPointArrays
            << std::endl;

  vtkIdType numberOfCellArrays = polydata->GetCellData()->GetNumberOfArrays();
  std::cout << "Number of CellData arrays: " << numberOfCellArrays << std::endl;

  std::cout << "Type table/key: " << std::endl;
  
  std::cout << VTK_UNSIGNED_CHAR << " unsigned char" << std::endl;
  std::cout << VTK_INT << "int" << std::endl;
  std::cout << VTK_UNSIGNED_INT << " unsigned int" << std::endl;
  std::cout << VTK_FLOAT << " float" << std::endl;
  std::cout << VTK_DOUBLE << " double" << std::endl;

  for (vtkIdType i = 0; i < numberOfPointArrays; i++)
  {
    int dataTypeID = polydata->GetPointData()->GetArray(i)->GetDataType();
    std::cout << "Array " << i << ": "
              << polydata->GetPointData()->GetArrayName(i)
              << " (type: " << dataTypeID << ")" << std::endl;
  }

  for (vtkIdType i = 0; i < numberOfCellArrays; i++)
  {
    int dataTypeID = polydata->GetCellData()->GetArray(i)->GetDataType();
    std::cout << "Array " << i << ": "
              << polydata->GetCellData()->GetArrayName(i)
              << " (type: " << dataTypeID << ")" << std::endl;
  }
}
} // namespace

The example compiles and works completely fine: I used a VTK file that I own, and this example yield the correct results:

Normals: 0x0
Number of PointData arrays: 0
Number of CellData arrays: 1
Type table/key: 
3 unsigned char
6 int
7 unsigned int
10 float
11 double
Array 0: CellEntityIds (type: 6)

---

Now, in my C++ codebase, I created a new very simple class:

// Standard includes
#include <string>

// VTK includes
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>

/**
 * @brief Container for the mesh of the vehicle.
 * @details This class will be powered with VTK engine.
 */
class SpaceObjectMesh {
   public:
    /**
     * @brief Construct a new mesh from an unstructured grid stored in a VTK file.
     * 
     * @param mesh_file Path to the VTK file containing the mesh.
     */
    explicit SpaceObjectMesh(std::string const mesh_file);
    /**
     * @brief Destroy a mesh instance.
     */
    ~SpaceObjectMesh() = default;

   private:
    /**
     * @brief Name of the file carrying the original unstructureed mesh, if any.
     */
    std::string _mesh_file;
    /**
     * @brief Handle to the VTK unstructured grid.
     */
    vtkSmartPointer<vtkPolyData> _polyd;
};

where the constructor contains the same code as the FindAllArrayNames example:

SpaceObjectMesh::SpaceObjectMesh(std::string const mesh_file) : _mesh_file(mesh_file) {
    vtkNew<vtkXMLPolyDataReader> reader;
    reader->SetFileName(mesh_file.c_str());
    reader->Update();
    _polyd = reader->GetOutput();
 
    FindAllData(polydata);
}

and the binding is also very simple:

    nb::class_<SpaceObjectMesh>(m, "SpaceObjectMesh")
            .def(nb::init<std::string const>(), "mesh_file"_a);

And now, in a test Python script if I do:

from orbital_propagation._ode_solver_kernel import SpaceObjectMesh
mesh_path = "objects/demo-sat/demo_sat.vtk"
_mesh = SpaceObjectMesh(mesh_path)

I get wrong results (regarding the pointdata / celldata arrays), and then I get a segfault:

Number of PointData arrays: 1
Number of CellData arrays: 0
Type table/key: 
3 unsigned char
6 int
7 unsigned int
10 float
11 double
zsh: segmentation fault  python 20231127_test_vtk_vehicle.py

lldb reveals that the crash happens there :

int dataTypeID = polydata->GetPointData()->GetArray(i)->GetDataType();

and somehow it makes sense because there are no PointData fields, so accessing the arrays should fail.
But why is reading the same file directly in C++, or in C++ through a Python binding, with the same code, not producing the same results ? Has anyone seen such a behavior before ?

---

Note that the vtk package is not installed in the python virtual env.

---

Thank you very much for your support !! 🙏

[tbridel]

It appears to have been a compiler problem where the compiler for the C++ test & the compiler for the whole codebase with nanobind wrapping wasn't the same. Turns out calling VTK methods compiled with llvm from a gcc code leads to completely random behaviors.