How to modify a TypedArray in a structure without modifying the underlying pointer in a mex file?

I have a mex file which receives a structure which has several fields as input and returns the same structure. One of the fields is a 2D double array.

I can read the data on the specific field, cast is to a TypedArrayRef<double> and modify it. But everytime I look at the structure address behind data (using format debug) in successive executions of the MEX file, the pointer to the array changes. Why is this?

I am following this example: https://de.mathworks.com/help/matlab/matlab_external/avoid-copies-of-large-arrays.html

Does this mean the data is being copied? I want to avoid copying the data.

[James Tursa]

We need to see your actual code before we can offer specific advice. In general, however, it is not possible for a mex routine to take inputs and modify them without deep data copies using only the official API functions. You will be forced to deep copy your data with API functions or use unofficial hacks (with potential unwanted side effects) if you insist on avoiding deep data copies.

[Simon Müller]

Hi @James Tursa, thank you for your answer. I am using exactly the example from here: https://de.mathworks.com/help/matlab/matlab_external/avoid-copies-of-large-arrays.html

So basically I use the following code:

#include "mex.hpp"
#include "mexAdapter.hpp"

using namespace matlab::data;
using matlab::mex::ArgumentList;

class MexFunction : public matlab::mex::Function {
public:
void operator()(ArgumentList outputs, ArgumentList inputs) {
checkArguments(inputs);
TypedArray<double> largeArray = std::move(inputs[0]);
for (auto& elem : largeArray) {
    if (elem < 0) {
        elem = 0;
        }
        }
        outputs[0] = largeArray;
        }
        
        void checkArguments(ArgumentList inputs) {
        std::shared_ptr<matlab::engine::MATLABEngine> matlabPtr = getEngine();
        ArrayFactory factory;
        
        if (inputs[0].getType() != ArrayType::DOUBLE ||
            inputs[0].getType() == ArrayType::COMPLEX_DOUBLE) {
            matlabPtr->feval(u"error", 0, 
            std::vector<Array>({ factory.createScalar("Incorrect input") }));
            }
            }
            };

I compile it with the mex command and execute it as follows:

format debug

testMatrix = magic(3)

testMatrix =

Structure address = f6d0cf00

m = 3

n = 3

pr = 1193c2e60

8 1 6

3 5 7

4 9 2

Then I run the mex as follows:

testMatrix = removeNegativeNumbers(testMatrix)

testMatrix =

Structure address = f6d0bf20

m = 3

n = 3

pr = 13df6e6e0

8 1 6

3 5 7

4 9 2

So the addresses change. The title of the help suggests there is a way of avoiding copies. Or am I missunderstanding something here?

[Simon Müller]

@James Tursa, Is this possible, or does the MATLAB API not allow something like it?

Answer 1

[Karan Singh]

Hi Simon,

The MATLAB Data API, which you're using in the provided C++ MEX example, is designed to be safe and to prevent accidental misuse of memory. When you pass data from MATLAB to a MEX function, MATLAB uses a copy-on-write strategy. This means that the data is not physically copied until you try to modify it. When you access the data in a read-only fashion, you are looking at the original data. However, once you modify the data, MATLAB will create a copy of the data to preserve the original data's integrity.

In the example you've provided, you're modifying the elements of the array with this loop:

for (auto& elem : largeArray) {
    if (elem < 0) {
        elem = 0;
    }
}

Hope this clarifies the doubt!