Efficiently Converting Java List to Matlab Matrix

Question

I am calling the Google Protocol Buffers Java API from Matlab. This works pretty well, but I have hit a big performance bottleneck. The bulk of the data are returned as objects of type:

java.util.Collections$UnmodifiableRandomAccessList

They actually contain a list of floats. I need to convert this to a Matlab matrix. The best approach I have found so far is to call:

cell2mat(cell(Q.toArray()))

However, that one line is a huge performance bottleneck in the code.

Note I am aware of the FarSounder Matlab parser generators for the Google Protocol Buffers, unfortunately these are very slow. See below for some rough benchmark speeds for my problem (YMMV). High is good.

Farsounder Matlab: 0.03
Pure Python: 1
Java API called from Matlab (parsing and extracting metadata only): 10
Java API called from Matlab (parsing and extracting both metadata and data): 0.25

If it wasn't for the overhead of converting the java.util.Collections$UnmodifiableRandomAccessList to a Matlab matrix, then the approach of calling the Java API from Matlab would look quite promising.

Is there a better way of converting this Java object into a Matlab matrix?

Bear in mind that the method returning this type is in automatically generated code.

my advice would be to minimize the number of times you call the MATLAB-Java bridge if possible. Say for example you were calling the Java code from inside a MATLAB loop, instead collect all outputs in Java code, then make a single call to this method from MATLAB. Can you share some minimal code for us to test (I know that the Java code is automatically generated)? — Amro, Jan 23 '14 at 15:41

score 7 · Accepted Answer · answered Jan 23 '14 at 15:48

You might be best writing a tiny piece of extra java code, like so:

import java.util.List;
import java.util.ListIterator;

class Helper {
    public static float[] toFloatArray(List l) {
        float retValue[] = new float[l.size()];
        ListIterator iterator = l.listIterator();
        for (int idx = 0; idx < retValue.length; ++idx ){
            // List had better contain float values,
            // or else the following line will ClassCastException.
            retValue[idx] = (float) iterator.next();
        }
        return retValue;
    }
}

with which I see:

>> j = java.util.LinkedList;
>> for idx = 1:1e5, j.add(single(idx)); end
>> tic, out = Helper.toFloatArray(j); toc
Elapsed time is 0.006553 seconds.
>> tic, cell2mat(cell(j.toArray)); toc
Elapsed time is 0.305973 seconds.

This work perfectly. Using this approach the benchmark speed of 0.25 has now increased to 6. This makes calling the JAVA API from Matlab the fastest of the approaches I have tried so far. I'm afraid I don't have enough reputation points to upvote this answer. — Andrew McLean, Jan 23 '14 at 17:04

score 1 · Answer 2 · answered Jan 23 '14 at 15:52

In my experience, the most performant solution is write a little set of java helpers, that converts the lists to plain arrays of primitive types. These are well mapped to matrices by matlab.

If the above e.g. gives a an array of java.lang.Floats, the helper could look like this:

public static float[] toFloats(Float[] floats) {
    float[] rv = new float[floats.length];
    for (int i=0; i < floats.length; i++) rv[i] = (float) floats[i];
    return rv;
}

In matlab cell2mat(cell(Q.toArray())) hence would become:

some.package.toFloats(Q.toArray());

Obviously you could modify the helper function to directly take your list as well, avoiding the need for the toArray() call (does this actually make a copy?).

Efficiently Converting Java List to Matlab Matrix

2 Answers2