counting calls to listCellSkin computeXX

CellSkinComputeHeightCounter.java

package control.skin;

import java.util.Locale;
import java.util.logging.Logger;

import static support.VirtualFlowTestUtils.*;

import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ListCell;
import javafx.scene.control.ListView;
import javafx.scene.control.skin.ListCellSkin;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyCodeCombination;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;
import javafx.stage.Window;
import support.FXUtils;

/**
 * https://bugs.openjdk.java.net/browse/JDK-8246745
 * 
 * accessing the fixedHeight is considered performance bottleneck.
 * 
 * Trying to measure .. 
 * 
 * with/out fixed size: total calls to (all) computeXXHeight == 1/5
 * 
 */
public class CellSkinComputeHeightCounter extends Application {

    ListView<?> list;
    private Parent createContent() {
        ObservableList<Locale> data = FXCollections.observableArrayList(Locale.getAvailableLocales());
        list = new ListView<>(data);
//        list.setFixedCellSize(20);
        Button debug = new Button("log visible counters");
        debug.setDefaultButton(true);
        debug.setOnAction(e -> {
//            firstLast(list);
            logVisibleCellCounters(list);
        });
        Button increaseHeight = new Button("increase");
        increaseHeight.setOnAction(e -> {
            Window window = increaseHeight.getScene().getWindow();
            double height = window.getHeight();
            window.setHeight(height + 200);
        });
        Button decreaseHeight = new Button("decrease");
        decreaseHeight.setOnAction(e -> {
            Window window = increaseHeight.getScene().getWindow();
            double height = window.getHeight();
            window.setHeight(height - 200);
        });
        
        BorderPane content = new BorderPane(list);
        content.setBottom(new HBox(10, debug, increaseHeight, decreaseHeight));
        
//        VBox content = new VBox(list, new HBox(10, debug, increaseHeight, decreaseHeight)) ;
        return content;
    }

    protected void firstLast(ListView<?> list) {
        ListCell<?> first = (ListCell<?>) getFirstVisibleCell(list);
        ListCell<?> last = (ListCell<?>) getLastVisibleCell(list);
        
        System.out.println("first/last: " + first.getText() + " " + first.getIndex() + 
                " / " + last.getText() + " " + last.getIndex());
    }

    private void logVisibleCellCounters(ListView<?> list) {
        ListCell<?> first = (ListCell<?>) getFirstVisibleCell(list);
        ListCell<?> last = (ListCell<?>) getLastVisibleCell(list);
        System.out.println("---------- first/last: " + first.getText() + " " + first.getIndex() + 
                " / " + last.getText() + " " + last.getIndex());
        doLog(list, first.getIndex(), last.getIndex());
    }
    
    private void doLog(ListView<?> list, int first, int last) {
        for (int i = first; i <= last; i++) {
            ListCell<?> cell = (ListCell) getCell(list, i);
            ListCellSkin<?> skin = (ListCellSkin<?>) cell.getSkin();
            int computeCounter = skin.minCounter + skin.prefCounter + skin.maxCounter;
            
            System.out.println(//cell.getText() + 
                    " instance/compute: " + skin.instanceCounter +  " / " + computeCounter
                    + " --- min/pref/max " + skin.minCounter + " / " + skin.prefCounter + " / " + skin.maxCounter);
        }
        
    }
    @Override
    public void start(Stage stage) throws Exception {
        stage.setScene(new Scene(createContent()));
        stage.setTitle(FXUtils.version());
        stage.show();
        stage.setX(stage.getX() - 200);
        
        stage.getScene().getAccelerators().put(new KeyCodeCombination(KeyCode.F1), 
                () -> logVisibleCellCounters(list));
    }

    public static void main(String[] args) {
        launch(args);
    }

    @SuppressWarnings("unused")
    private static final Logger LOG = Logger
            .getLogger(CellSkinComputeHeightCounter.class.getName());

}

ListCellSkin.java

/*
 * Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package javafx.scene.control.skin;

import com.sun.javafx.scene.control.behavior.BehaviorBase;
import com.sun.javafx.scene.control.behavior.ListCellBehavior;

import javafx.geometry.Orientation;
import javafx.scene.control.Control;
import javafx.scene.control.ListCell;
import javafx.scene.control.ListView;
import javafx.scene.layout.Region;

/**
 * Default skin implementation for the {@link ListCell} control.
 *
 * @see ListCell
 * @since 9
 */
public class ListCellSkin<T> extends CellSkinBase<ListCell<T>> {

    /***************************************************************************
     *                                                                         *
     * Private fields                                                          *
     *                                                                         *
     **************************************************************************/

    private final BehaviorBase<ListCell<T>> behavior;

    /***************************************************************************
     *                                                                         *
     * Constructors                                                            *
     *                                                                         *
     **************************************************************************/

    /**
     * Creates a new ListCellSkin instance, installing the necessary child
     * nodes into the Control {@link Control#getChildren() children} list, as
     * well as the necessary input mappings for handling key, mouse, etc events.
     *
     * @param control The control that this skin should be installed onto.
     */
    public ListCellSkin(ListCell<T> control) {
        super(control);

        // install default input map for the ListCell control
        behavior = new ListCellBehavior<>(control);
//        control.setInputMap(behavior.getInputMap());
        
        instanceCounter = classCounter++;
    }

    /***************************************************************************
     *                                                                         *
     * Public API                                                              *
     *                                                                         *
     **************************************************************************/

    /** {@inheritDoc} */
    @Override public void dispose() {
        super.dispose();

        if (behavior != null) {
            behavior.dispose();
        }
    }

    
    /** {@inheritDoc} */
    @Override protected double computePrefWidth(double height, double topInset, double rightInset, double bottomInset, double leftInset) {
        double pref = super.computePrefWidth(height, topInset, rightInset, bottomInset, leftInset);
        ListView<T> listView = getSkinnable().getListView();
        return listView == null ? 0 :
            listView.getOrientation() == Orientation.VERTICAL ? pref : Math.max(pref, getCellSize());
    }

    private static int classCounter;
    public final int instanceCounter;
    public int prefCounter;
    public int minCounter;
    public int maxCounter;
    
    /** {@inheritDoc} */
    @Override protected double computePrefHeight(double width, double topInset, double rightInset, double bottomInset, double leftInset) {
        prefCounter++;
        double fixedCellSize = getFixedCellSize();
        if (fixedCellSize > 0) {
            return fixedCellSize;
        }

        // Added the comparison between the default cell size and the requested
        // cell size to prevent the issue identified in RT-19873.
        final double cellSize = getCellSize();
        final double prefHeight = cellSize == DEFAULT_CELL_SIZE ? super.computePrefHeight(width, topInset, rightInset, bottomInset, leftInset) : cellSize;
        return prefHeight;
    }

    /** {@inheritDoc} */
    @Override protected double computeMinHeight(double width, double topInset, double rightInset, double bottomInset, double leftInset) {
        minCounter++;
        double fixedCellSize = getFixedCellSize();
        if (fixedCellSize > 0) {
            return fixedCellSize;
        }

        return super.computeMinHeight(width, topInset, rightInset, bottomInset, leftInset);
    }

    /** {@inheritDoc} */
    @Override protected double computeMaxHeight(double width, double topInset, double rightInset, double bottomInset, double leftInset) {
        maxCounter++;
        double fixedCellSize = getFixedCellSize();
        if (fixedCellSize > 0) {
            return fixedCellSize;
        }
        return super.computeMaxHeight(width, topInset, rightInset, bottomInset, leftInset);
    }

    private double getFixedCellSize() {
        ListView<?> listView = getSkinnable().getListView();
        return listView != null ? listView.getFixedCellSize() : Region.USE_COMPUTED_SIZE;
    }
}