Changeset 10697 in josm for trunk


Ignore:
Timestamp:
2016-08-01T22:56:04+02:00 (4 years ago)
Author:
Don-vip
Message:

fix #13258 - Pull benchmark code out of renderer (patch by michael2402) - gsoc-core

Location:
trunk
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/StyledMapRenderer.java

    r10662 r10697  
    3737import java.util.concurrent.ForkJoinTask;
    3838import java.util.concurrent.RecursiveTask;
     39import java.util.function.Supplier;
    3940
    4041import javax.swing.AbstractButton;
     
    6364import org.openstreetmap.josm.gui.mappaint.StyleElementList;
    6465import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
    65 import org.openstreetmap.josm.gui.mappaint.mapcss.Selector;
    6666import org.openstreetmap.josm.gui.mappaint.styleelement.AreaElement;
    6767import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement;
     
    192192    }
    193193
    194     private static class StyleRecord implements Comparable<StyleRecord> {
     194    public static class StyleRecord implements Comparable<StyleRecord> {
    195195        private final StyleElement style;
    196196        private final OsmPrimitive osm;
     
    240240            return Float.compare(this.style.objectZIndex, other.style.objectZIndex);
    241241        }
    242     }
    243 
    244     /**
    245      * Saves benchmark data for tests.
    246      */
    247     public static class BenchmarkData {
    248         public long generateTime;
    249         public long sortTime;
    250         public long drawTime;
    251         public Map<Class<? extends StyleElement>, Integer> styleElementCount;
    252         public boolean skipDraw;
    253 
    254         private void recordElementStats(List<StyleRecord> srs) {
    255             styleElementCount = new HashMap<>();
    256             for (StyleRecord r : srs) {
    257                 Class<? extends StyleElement> klass = r.style.getClass();
    258                 Integer count = styleElementCount.get(klass);
    259                 if (count == null) {
    260                     count = 0;
    261                 }
    262                 styleElementCount.put(klass, count + 1);
    263             }
    264 
    265         }
    266     }
    267 
    268     /* can be set by tests, if detailed benchmark data is requested */
    269     public BenchmarkData benchmarkData;
     242
     243        /**
     244         * Get the style for this style element.
     245         * @return The style
     246         */
     247        public StyleElement getStyle() {
     248            return style;
     249        }
     250    }
    270251
    271252    private static Map<Font, Boolean> IS_GLYPH_VECTOR_DOUBLE_TRANSLATION_BUG = new HashMap<>();
     
    373354    private boolean leftHandTraffic;
    374355    private Object antialiasing;
     356
     357    private Supplier<RenderBenchmarkCollector> benchmarkFactory = RenderBenchmarkCollector.defaultBenchmarkSupplier();
    375358
    376359    /**
     
    19021885    }
    19031886
     1887    /**
     1888     * Sets the factory that creates the benchmark data receivers.
     1889     * @param benchmarkFactory The factory.
     1890     * @since 10697
     1891     */
     1892    public void setBenchmarkFactory(Supplier<RenderBenchmarkCollector> benchmarkFactory) {
     1893        this.benchmarkFactory = benchmarkFactory;
     1894    }
     1895
    19041896    @Override
    19051897    public void render(final DataSet data, boolean renderVirtualNodes, Bounds bounds) {
     1898        RenderBenchmarkCollector benchmark = benchmarkFactory.get();
    19061899        BBox bbox = bounds.toBBox();
    19071900        getSettings(renderVirtualNodes);
    1908         boolean benchmarkOutput = Main.isTraceEnabled() || Main.pref.getBoolean("mappaint.render.benchmark", false);
    1909         boolean benchmark = benchmarkOutput || benchmarkData != null;
    19101901
    19111902        data.getReadLock().lock();
     
    19131904            highlightWaySegments = data.getHighlightedWaySegments();
    19141905
    1915             long timeStart = 0, timeGenerateDone = 0, timeSortingDone = 0, timeFinished;
    1916             if (benchmark) {
    1917                 timeStart = System.currentTimeMillis();
    1918                 if (benchmarkOutput) {
    1919                     System.err.print("BENCHMARK: rendering ");
    1920                 }
    1921             }
     1906            benchmark.renderStart(circum);
    19221907
    19231908            List<Node> nodes = data.searchNodes(bbox);
     
    19371922                    Math.max(100, (nodes.size() + ways.size()) / THREAD_POOL.getParallelism() / 3)));
    19381923
    1939             if (benchmark) {
    1940                 timeGenerateDone = System.currentTimeMillis();
    1941                 if (benchmarkOutput) {
    1942                     System.err.print("phase 1 (calculate styles): " + Utils.getDurationString(timeGenerateDone - timeStart));
    1943                 }
    1944                 if (benchmarkData != null) {
    1945                     benchmarkData.generateTime = timeGenerateDone - timeStart;
    1946                 }
     1924            if (!benchmark.renderSort()) {
     1925                return;
    19471926            }
    19481927
    19491928            Collections.sort(allStyleElems); // TODO: try parallel sort when switching to Java 8
    19501929
    1951             if (benchmarkData != null) {
    1952                 timeSortingDone = System.currentTimeMillis();
    1953                 benchmarkData.sortTime = timeSortingDone - timeGenerateDone;
    1954                 if (benchmarkData.skipDraw) {
    1955                     benchmarkData.recordElementStats(allStyleElems);
    1956                     return;
    1957                 }
     1930            if (!benchmark.renderDraw(allStyleElems)) {
     1931                return;
    19581932            }
    19591933
     
    19691943            }
    19701944
    1971             if (benchmark) {
    1972                 timeFinished = System.currentTimeMillis();
    1973                 if (benchmarkData != null) {
    1974                     benchmarkData.drawTime = timeFinished - timeGenerateDone;
    1975                     benchmarkData.recordElementStats(allStyleElems);
    1976                 }
    1977                 if (benchmarkOutput) {
    1978                     System.err.println("; phase 2 (draw): " + Utils.getDurationString(timeFinished - timeGenerateDone) +
    1979                         "; total: " + Utils.getDurationString(timeFinished - timeStart) +
    1980                         " (scale: " + circum + " zoom level: " + Selector.GeneralSelector.scale2level(circum) + ')');
    1981                 }
    1982             }
    1983 
    19841945            drawVirtualNodes(data, bbox);
     1946
     1947            benchmark.renderDone();
    19851948        } finally {
    19861949            data.getReadLock().unlock();
  • trunk/test/performance/org/openstreetmap/josm/gui/mappaint/MapRendererPerformanceTest.java

    r10222 r10697  
    1111import java.util.Collections;
    1212import java.util.EnumMap;
     13import java.util.HashMap;
    1314import java.util.List;
    1415import java.util.Locale;
    1516import java.util.Map;
     17import java.util.stream.Collectors;
    1618
    1719import javax.imageio.ImageIO;
     
    3032import org.openstreetmap.josm.data.coor.LatLon;
    3133import org.openstreetmap.josm.data.osm.DataSet;
     34import org.openstreetmap.josm.data.osm.visitor.paint.RenderBenchmarkCollector.CapturingBenchmark;
    3235import org.openstreetmap.josm.data.osm.visitor.paint.StyledMapRenderer;
     36import org.openstreetmap.josm.data.osm.visitor.paint.StyledMapRenderer.StyleRecord;
    3337import org.openstreetmap.josm.data.projection.Projections;
    3438import org.openstreetmap.josm.gui.NavigatableComponent;
     
    208212                    Main.warn(ex);
    209213                }
    210                 StyledMapRenderer.BenchmarkData data = new StyledMapRenderer.BenchmarkData();
    211                 data.skipDraw = skipDraw;
    212                 renderer.benchmarkData = data;
     214                BenchmarkData data = new BenchmarkData();
     215                renderer.setBenchmarkFactory(() -> data);
    213216                renderer.render(dsCity, false, bounds);
    214217
    215218                if (i > noWarmup) {
    216                     generateTimes.add(data.generateTime);
    217                     sortTimes.add(data.sortTime);
    218                     drawTimes.add(data.drawTime);
    219                     totalTimes.add(data.generateTime + data.sortTime + data.drawTime);
     219                    generateTimes.add(data.getGenerateTime());
     220                    sortTimes.add(data.getSortTime());
     221                    drawTimes.add(data.getDrawTime());
     222                    totalTimes.add(data.getGenerateTime() + data.getSortTime() + data.getDrawTime());
    220223                }
    221224                if (i == 1) {
     
    318321    }
    319322
    320     public static void dumpTimes(StyledMapRenderer.BenchmarkData bd) {
    321         System.out.print(String.format("gen. %3d, sort %3d, draw %3d%n", bd.generateTime, bd.sortTime, bd.drawTime));
    322     }
    323 
    324     public static void dumpElementCount(StyledMapRenderer.BenchmarkData bd) {
    325         String sep = null;
    326         for (Map.Entry<Class<? extends StyleElement>, Integer> e : bd.styleElementCount.entrySet()) {
    327             if (sep == null) {
    328                 sep = " ";
    329             } else {
    330                 System.out.print(sep);
    331             }
    332             System.out.print(e.getKey().getSimpleName().replace("Element", "") + ":" + e.getValue());
    333         }
    334         System.out.println();
     323    public static void dumpTimes(BenchmarkData bd) {
     324        System.out.print(String.format("gen. %3d, sort %3d, draw %3d%n", bd.getGenerateTime(), bd.getSortTime(), bd.getDrawTime()));
     325    }
     326
     327    public static void dumpElementCount(BenchmarkData bd) {
     328        System.out.println(bd.recordElementStats().entrySet().stream()
     329                .map(e -> e.getKey().getSimpleName().replace("Element", "") + ":" + e.getValue()).collect(Collectors.joining(" ")));
     330    }
     331
     332    public static class BenchmarkData extends CapturingBenchmark {
     333
     334        private List<StyleRecord> allStyleElems;
     335
     336        @Override
     337        public boolean renderDraw(List<StyleRecord> allStyleElems) {
     338            this.allStyleElems = allStyleElems;
     339            return super.renderDraw(allStyleElems);
     340        }
     341
     342        private Map<Class<? extends StyleElement>, Integer> recordElementStats() {
     343            Map<Class<? extends StyleElement>, Integer> styleElementCount = new HashMap<>();
     344            for (StyleRecord r : allStyleElems) {
     345                Class<? extends StyleElement> klass = r.getStyle().getClass();
     346                Integer count = styleElementCount.get(klass);
     347                if (count == null) {
     348                    count = 0;
     349                }
     350                styleElementCount.put(klass, count + 1);
     351            }
     352            return styleElementCount;
     353        }
    335354    }
    336355}
Note: See TracChangeset for help on using the changeset viewer.