dim3 | Software 's dimension3 content-free 3D game/engine

You can make the kernel move through both a and b simultaneously, like this:

Yes it is possible, as long as you have the Distributed Computing Toolbox/Parallel computing toolbox of MATLAB.

The toolbox allows to have a thing called gpuArrays in normal MATLAB code, but it also has a C interface where you can get and set these MATLAB arrays GPU addresses.

You can find the documentation here:

https://uk.mathworks.com/help/parallel-computing/gpu-cuda-and-mex-programming.html?s_tid=CRUX_lftnav

For example, for the first input to a mex file:

First of all, I suggest that performance questions include complete codes. I generally need to be able to run stuff, and you can save me some typing. Sure, you can leave stuff out. Sure, I can probably figure out what it is. But I'm less likely to help you that way, and I suspect I'm not alone in that view. My advice: Make it easy for others to help you. I've given examples of what would be useful below.

On to the question:

The difference is that C uses a 1D array whereas Fortran uses 2D. But that should not be a problem since underneath the memory will be contiguous.

TL;DR: Your claim ("that should not be a problem") is evidently not supportable. The difference between a 1D allocation and a 2D allocation matters, not only from a storage perspective but also from an index-calculation perspective. If you're sensitive to the length of this answer, skip to note D at the bottom of this post.

Details:

When we have a loop like this:

Forgot to use ceil when calculating grid dimensions.

For an even number of rows in the array, you should be able to do something like this:

harr is not allocated. You should allocated it on the host side using for example malloc before calling cudaMemcpy. As a result, the printed values you look are garbage. This is quite surprising that the program did not segfault on your machine.

Moreover, when you call the kernel findMin at the end, its parameter is harr (which is supposed to be on the host side regarding its name) should be on the device to perform the atomic operation correctly. As a result, the current kernel call is invalid.

As pointed out by @RobertCrovella, a cudaDeviceSynchronize() call is missing at the end. Moreover, you need to free your memory using cudaFree.

I can't compile your code as is, but the problem is that np.shape returns (rows,columns) or the equivalent (height,width), not (width,height):

As per the comment, you need extern "C"

C++ (and by extension cuda) does something called name mangling

Try this with and without the extern "C"

Your two-dimensional array - in the first version of the program - is implemented using an array of pointers, each of which to a separately-allocated array of double values.

In your second version, you are using the same pointer-to-pointer-to-double type, but - you're not allocating any space for the actual data, just for the array of pointers (and not copying any of the data to the GPU - just the pointers; which are useless to copy anyway, since they're pointers to host-side memory.)

What is most likely happening is that your kernel attempts to access memory at an invalid address, and its execution is aborted.

If you were to properly check for errors, as @njuffa noted, you would know that is what happened.

Now, you could avoid having to make multiple memory allocations if you were to use a single data area instead of separate allocations for each second-dimension 1D array; and that is true both for the first and the second version of your program. That would not quite be array flattening. See an explanation of how to do this (C-language-style) on this page.

Note, however, that double-dereferencing, which you insist on performing in your kernel, is likely slowing it down significantly.