Description Michał Rapacz 2017-07-04 09:51:54 EDT

Expanding large trees on linux takes very long time and it is about 10x slower than on Windows. For example, expanding tree node with 20k children in a tree viewer with 10 columns takes ~8 seconds on Windows 7, while on linux it takes ~2 minutes (same machine). Similar results were observed on multiple linux machines running RedHat/Fedora/Debian. Switching between gtk2/gtk3 does not make any noticeable difference.

Here is some sample code:

import java.util.stream.Collectors;
import java.util.stream.IntStream;

import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.TreeColumnLayout;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;

public class Performance {

    public static void main(final String[] args) {
        final Display display = new Display();
        final Shell shell = new Shell(display);

        final Composite viewerComposite = new Composite(shell, SWT.NONE);
        final Tree tree = new Tree(viewerComposite, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
        final TreeViewer viewer = new TreeViewer(tree);

        final TreeColumnLayout columnLayout = new TreeColumnLayout();
        viewerComposite.setLayout(columnLayout);
        for (int i = 0; i < 10; i++) {
            final TreeColumn column = new TreeColumn(tree, SWT.NONE);
            column.setText(Integer.toString(i));
            columnLayout.setColumnData(column, new ColumnWeightData(1));
            final TreeViewerColumn col = new TreeViewerColumn(viewer, column);
            col.setLabelProvider(new ColumnLabelProvider() {

                @Override
                public String getText(final Object element) {
                    return element.toString();
                }
            });
        }

        GridDataFactory.fillDefaults().grab(true, true).hint(800, 600).applyTo(viewerComposite);

        viewer.setContentProvider(new ITreeContentProvider() {

            @Override
            public Object[] getElements(final Object inputElement) {
                if ("root".equals(inputElement.toString())) {
                    return new String[] { "rootWithManyChildren" };
                } else {
                    return getChildren(inputElement);
                }
            }

            @Override
            public Object[] getChildren(final Object parentElement) {
                return IntStream.range(0, 20000)
                        .boxed()
                        .map(i -> i.toString())
                        .collect(Collectors.toList())
                        .toArray(new String[0]);
            }

            @Override
            public Object getParent(final Object element) {
                return null;
            }

            @Override
            public boolean hasChildren(final Object element) {
                return true;
            }

            @Override
            public void dispose() {
                // do nothing
            }

            @Override
            public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) {
                // do nothing
            }

        });
        viewer.getTree().setHeaderVisible(true);
        viewer.setInput("root");

        viewerComposite.setBounds(0, 0, 800, 600);
        shell.setSize(820, 620);
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }
}

The problem can be observed when expanding the root node in the sample app.

Is there any reason for such huge performance difference between windows and linux? Is there a way to improve it so expanding large trees under gtk would take some more reasonable time?