Not sure, looking at the swig code, I don't really see much of a reason these should differ. Could it be that the problem is just the new which is then free'd using free (by swig/NumPy)?

EDIT: To be a bit more clear, please try this using malloc instead of new.

I don't think so, as the getw function does the same thing and runs without error, and it is only the getw2 function that has the seg fault issue. Moreover, swig only issues a warning when wrapping the getw2 function, and the warning points to int* begin freed via the PyCapsule object. In the getw function, it is the double** pointer that is being freed via the PyCapsule object.

Also, since replacing ARGOUTVIEWM with ARGOUTVIEW for the getw2 function results in working code, this leads me to believe that the free is working fine, and it is ARGOUTVIEWM that is causing the problem.

EDIT: I just tried replacing the new with malloc, and the same issue persists.

I've never heard of ARGOUTVIEWM before - is it a numpy thing or a swig thing - and where is the behavior implemented?

Well, the main difference between ARGOUTVIEWM and ARGOUTVIEW appears to be that ARGOUTVIEW does not free the memory, if I read the code correctly. So that is where my guess came from. And swig definitely uses free to free that memory, and while I do not know C++ well, mixing new and free seems probably not good. So, I do think you have to use malloc: https://stackoverflow.com/questions/4061514/c-object-created-with-new-destroyed-with-free-how-bad-is-this

@leakec sorry for being pedantic, but you tried replacing both new with malloc, right?

The only other idea I have is that dimensions are normally npy_intp and not int, but since the %apply you got spells out int, I do not really see swig not casting the int correctly.

@eric-wieser it seems to be defined here:

Ah, found it:

@seberg No worries, yes I replaced both calls to new with malloc, and still the same issue. Its probably worth noting that I have used swig to wrap C++ in the past and have used new almost every time without issue. However, in the past I have always used ARGOUTVIEW arrays, as the programs were small enough that I did not need to use ARGOUTVIEWM arrays to release the memory after it is used.

@eric-wieser Yes, that is what I see as well. When using (double** ARGOUTVIEWM_ARRAY2, int* DIM1, int* DIM2) the program appears to wrap correctly, and the free is called on the double** argument. Whereas when using (int* DIM1, int* DIM2, double** ARGOUTVIEWM_ARRAY2) the free is called on one of the int* arguments instead. My guess is that there is an issue in the typemap that has the ARGOUTVIEWM argument last.

I think I found it! See this snippet of the numpy.i file:

/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
 */
%typemap(in,numinputs=0)
  (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )
  (DATA_TYPE*  data_temp = NULL  , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)
{
  $1 = &data_temp;
  $2 = &dim1_temp;
  $3 = &dim2_temp;
}
%typemap(argout,
         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
  (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
{
  npy_intp dims[2] = { *$2, *$3 };
  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
  PyArrayObject* array = (PyArrayObject*) obj;

  if (!array) SWIG_fail;

%#ifdef SWIGPY_USE_CAPSULE
    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
%#else
    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
%#endif

%#if NPY_API_VERSION < 0x00000007
  PyArray_BASE(array) = cap;
%#else
  PyArray_SetBaseObject(array,cap);
%#endif

  $result = SWIG_Python_AppendOutput($result,obj);
}

/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2)
 */
%typemap(in,numinputs=0)
  (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEWM_ARRAY2)
  (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp = NULL  )
{
  $1 = &dim1_temp;
  $2 = &dim2_temp;
  $3 = &data_temp;
}
%typemap(argout,
         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2)
{
  npy_intp dims[2] = { *$1, *$2 };
  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
  PyArrayObject* array = (PyArrayObject*) obj;

  if (!array) SWIG_fail;

%#ifdef SWIGPY_USE_CAPSULE
    PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
%#else
    PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free);
%#endif

%#if NPY_API_VERSION < 0x00000007
  PyArray_BASE(array) = cap;
%#else
  PyArray_SetBaseObject(array,cap);
%#endif

  $result = SWIG_Python_AppendOutput($result,obj);
}

As you can see, the ($1) argument is freed in both cases. If I switch the freed arguments to ($3) in the second case, the case where the ARGOUTVIEWM array is the last argument , it works!

I see the bug.

 %#ifdef SWIGPY_USE_CAPSULE 
     PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 
 %#else 
     PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 
 %#endif

should be

 %#ifdef SWIGPY_USE_CAPSULE 
     PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap); 
 %#else 
     PyObject* cap = PyCObject_FromVoidPtr((void*)(*$3), free); 
 %#endif

@seberg's warnings about new vs malloc are valid though - mixing them is undefined behavior, meaning you might get away with it until without warning you won't. Don't take the risk.

@seberg Great minds think alike :)

I'll propose the fix in a few minutes.

Looks like we cross-posted. Mind making a PR? Perhaps even check the others too, if you're feeling generous.

@leakec thanks for digging it out, had not noticed that typo obviously! A PR would be great, I am not sure if we run tests, but there do seem swig specific tests in the folder.

@seberg @eric-wieser Sure thing, I will check the other ARGOUTVIEWM arrays as well. I'm pretty new to open source thing, so it will take me a few minutes to figure out how to make the PR correctly.

@seberg @eric-wieser I was able to correct all of the ARGOUTVIEWM memory de-allocation. However, adding an ARGOUTVIEWM case to the current unit tests for testArray.py results in a double free. I believe this is because the Array class already deallocates that memory. Would you like me to create a separate unit test for the ARGOUTVIEWM arrays?
EDIT: Submitted pull request that includes modified numpy.i file, but no changes to the tests. Please let me know if you would like me to create a new test for the ARGOUTVIEWM array typemaps.