Returning a torch::Tensor causes seg fault in Python when returning from a C++ binding with pybind11

I have data from a device that is being captured in Python as arrays and then sent to a C++ binding to speed up some post processing that must happen to format the data properly and convert into a torch.Tensor using a lot of iterative tasks and libtorch for the final conversion to a tensor. I'm using pybind11 to bind C++ function to python.

I have tested this function (processing ) in the C++ implementation and it does in fact process my data correctly and create a tensor with the proper shape and data, but I'm having weird memory issues on the C++ -> Python boundary when returning from the binding.

Basically what happens that I get the final tensor from C++ and return it to python. I am assigning the return tensor to a variable in python, which works. I can access information like the shape, and datatype of the tensor, but when I try to access any of the array-like data (using indexing, or printing the tensor, etc) I get a seg fault sometimes, depending on the shape of the tensor.

From what I can tell by , this has to do with some memory issues with how C++ and Python are calling destructors. It looks like python is basically creating a shallow copy of the tensor, so I can access it's information like shape, but the actual underlying data is being destroyed by C++ and so I'm essentially trying to access a null pointer (that's what I think from what I've been seeing). I tried using py::return_value_policy::copy to stop this, but it has not worked (I've tried all of the return value policies and none of them work).

However, this behavior is very strange because it only happens with certain tensor sizes, like oddly specific sizes (see below).

This is my C++ function signature and pybind module:

// processing.cpp #include <torch/torch.h> #include <pybind11/pybind11.h> namespace pybind11 as py; torch::Tensor processing(py::array np_data, py::array dim){ // Lots of working code here, converts numpy to uint8_t C array // to do necessary C stuff // ... // data_array is a C-style array of uint16_t auto options = torch::TensorOptions().dtype(torch::kUInt8); torch::Tensor output = torch::from_blob(data_array, options); finalOutput = torch::reshape(output, /*proper output shape*/); return finalOutput; } // Create python bindings PYBIND11_MODULE(processing_ext, m, py::mod_gil_not_used()){ m.def("processing", &processing, py::arg("batchOutputs"), py::arg("dim"), py::return_value_policy::copy ); }

I compile with ninja with the following setup.py because cmake has been a pain with python3 setup.py build:

# setup.py from setuptools import setup from torch.utils.cpp_extension import CppExtension, BuildExtension import os setup( name="processing_ext", ext_modules=[ CppExtension( name="processing_ext", sources=["processing.cpp"], extra_compile_args=[], ), ], cmdclass={ 'build_ext': BuildExtension } )

Then I call my binding from python.

# test.py import torch import processing_ext # My c++ binding # Dimensions batch_size: int = 5 num_neurons: int = 32 data_len: int = 28 data_wid: int = 28 data: np.ndarray = ... # My data output_shape: np.ndarray = np.ndarray([batch_size, num_neurons, data_len, data_wid]) # Call my C++ binding output: torch.Tensor = processing_ext.processing(data, output_shape)

The above code will work at the dimensions listed in test.py above, but not with all sizes. Specifically, keeping all other dimensions the same, it will work when num_neurons is between 1-5, or 18-35, but not when between 6 to 17 or 36 to infinity (all are inclusive ranges).

Any ideas of why this seg faults for some sizes but not others?

I'm using Python 3.12.3 on Ubuntu 24.04.4, with torch 2.7.1 and pybind11 2.11.2.