Initializing and keeping track of a large c++ object and reusing it from inside Mathematica

Question

I have a c++ library function that calculates a distance between two vectors given an underlying matrix.

int d(const vector<float>& v1, const vector<float>& v2, const vector<vector<int>>& m) {
\\lots of stuff I don't want to understand 
}

Now the matrix m can be quite big and expensive to create. It has the same value for many evaluations of d. It only depends on an integer i that is determined once in a while during runtime.

So I would like to pass i and initialize m. Can I somehow initialize m as a c++ vector of vectors by calling c++ from Mathematica passing i and then somehow keep a handle on this c++ structure that I can pass to d(v1,v2,m)?

Or do I have to store the matrix in Mathematica itself? My fear is that it will be much bigger than the c++ equivalent and in the long run the memory usage will be a factor.

I hope the question is clear. I read many pages of documentation, but I could not figure out how to create and keep data on the c++ side in between calls. Maybe this question is similar, but I don't understand the example actually. And it has no answer.

Answer 1

This can be done without using any Mathematica features. You can keep the matrix as a global variable on the C++ side. You will have a function for initializing it, a function for destroying it, and a function for the distance calculation. Then just call the initializer and cleanup function manually from Mathematica when you need to.

Note: Storing a large matrix as std::vector< std::vector<...> > in C++ is not a good idea if you need performance. Write your own class instead which stores the matrix as a flat array and indexes into it as i*n + j or similar.

If you need very good performance, do not use MathLink. Use LibraryLink instead. With LibraryLink, you can use "constant passing" for tensors: you can pass a Mathematica matrix to C++ without making an in-memory copy of it (and have read-only access on the C++ side). See "Memory management of MTensors" in the LibraryLink documentation.

Since version 10, LibraryLink also provides "managed library expressions" (see again the LibraryLink tutorial). These make it possible to have C-side data structures which get destroyed automatically once Mathematica no longer holds references to them. This might simplify the first type of solution I mentioned where you have an initializer function and a cleanup function for the matrix. It will ensure that the cleanup function gets called automatically once there's no Mathematica side reference to the matrix.

Also take a look at my package LTemplate which makes it easier to write this sort of code with managed library expressions.

With LTemplate the solution would look something like this (sorry for not testing this, I must leave in minutes):

The template:

template = LClass["Distance",
              {LFun["setMatrix", {Integer}, "Void"],
               LFun["dist", {{Real, 1, "Constant"}, {Real, 1, "Constant"}}, Real]}
           ];

C++ code:

class Distance {
    YourMatrixType m; // may even be an mma::RealMatrixRef, i.e. an MTensor
public:
    ~Distance() { /* must clean up m if already initialized */ }

    void setMatrix(mint i) { /* initialize m */ }

    double dist(mma::RealTensorRef v1, mma::RealTensorRef v2) const {
        // compute distance between v1 and v2 based on m
    }
};

Now in Mathematica:

CompileTemplate[template]
obj = Make["Distance"]
obj@"setMatrix"[i]
obj@"dist"[v1, v2]

When there's no more references held by Mathematica to obj (e.g. you do obj =. and it's not stored in Out[...] either) then the destructor will automatically be called and the matrix m is freed.