Google Git Google Git
Sign in
third-party-mirror/openjdk/jdk25u/HEAD/./test/jdk/performance/client/RenderPerfTest/src/renderperf/RenderPerfTest.java
blob: 15a5cdf5665d87c3773229b140f8deb6e5336844 [file]
/*
* Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, JetBrains s.r.o.. 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.
*
* 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 renderperf;
import java.awt.AWTException;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Insets;
import java.awt.LinearGradientPaint;
import java.awt.Point;
import java.awt.RadialGradientPaint;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.Transparency;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import java.awt.geom.QuadCurve2D;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferShort;
import java.awt.image.VolatileImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.IntBinaryOperator;
import java.util.regex.Pattern;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
public final class RenderPerfTest {
private final static String VERSION = "RenderPerfTest 2024.02";
private static final HashSet<String> ignoredTests = new HashSet<>();
static {
// add ignored tests here
// ignoredTests.add("testMyIgnoredTest");
ignoredTests.add("testCalibration"); // not from command line
}
private final static String EXEC_MODE_ROBOT = "robot";
private final static String EXEC_MODE_BUFFER = "buffer";
private final static String EXEC_MODE_VOLATILE = "volatile";
private final static String EXEC_MODE_DEFAULT = EXEC_MODE_ROBOT;
public final static List<String> EXEC_MODES = Arrays.asList(EXEC_MODE_ROBOT, EXEC_MODE_BUFFER, EXEC_MODE_VOLATILE);
private static String EXEC_MODE = EXEC_MODE_DEFAULT;
private final static String GC_MODE_DEF = "def";
private final static String GC_MODE_ALL = "all";
private static String GC_MODE = GC_MODE_DEF;
// System properties:
private final static boolean CALIBRATION = "true".equalsIgnoreCase(System.getProperty("CALIBRATION", "false"));
private final static boolean REPORT_OVERALL_FPS = "true".equalsIgnoreCase(System.getProperty("REPORT_OVERALL_FPS", "false"));
private final static boolean DUMP_SAMPLES = "true".equalsIgnoreCase(System.getProperty("DUMP_SAMPLES", "false"));
private final static boolean TRACE = "true".equalsIgnoreCase(System.getProperty("TRACE", "false"));
private final static boolean TRACE_CONFIGURE = "true".equalsIgnoreCase(System.getProperty("TRACE_CONFIGURE", "false"));
private final static boolean TRACE_SYNC = "true".equalsIgnoreCase(System.getProperty("TRACE_SYNC", "false"));
private final static boolean DELAY_START = "true".equalsIgnoreCase(System.getProperty("DelayStart", "false"));
private final static boolean DELAY_TEST = "true".equalsIgnoreCase(System.getProperty("DelayTest", "false"));
private final static boolean ROBOT_TIME_DELAY = "true".equalsIgnoreCase(System.getProperty("ROBOT_TIME_DELAY", "true"));
private final static boolean ROBOT_TIME_ROUND = "true".equalsIgnoreCase(System.getProperty("ROBOT_TIME_ROUND", "false"));
private final static boolean TEXT_VERSION = "true".equalsIgnoreCase(System.getProperty("TEXT_VERSION", "true"));
// time scale multiplier to get more samples so refined metrics:
private final static int TIME_SCALE = Integer.getInteger("TIME_SCALE", 1);
// default settings:
private static boolean VERBOSE = false;
private static boolean VERBOSE_FONT_CONFIG = false;
private static boolean VERBOSE_GRAPHICS_CONFIG = false;
private static int REPEATS = 1;
private static boolean USE_FPS = true;
private static int NW = 1;
private final static int N_DEFAULT = 1000;
private static int N = N_DEFAULT;
private final static float WIDTH = 800;
private final static float HEIGHT = 800;
private final static float R = 25;
private final static int BW = 50;
private final static int BH = 50;
private final static int IMAGE_W = (int) (WIDTH + BW);
private final static int IMAGE_H = (int) (HEIGHT + BH);
// Test attributes:
private static String TEXT_STR = TEXT_VERSION ? VERSION : "The quick brown fox jumps over the lazy dog";
private static String TEXT_FONT = Font.DIALOG;
private static int TEXT_SIZE_DEFAULT = 12;
private static int TEXT_SIZE_LARGE = 32;
private final static int COUNT = 600 * TIME_SCALE;
private final static int MIN_COUNT = 20;
private final static int MAX_SAMPLE_COUNT = 2 * COUNT;
private static int WARMUP_COUNT = MIN_COUNT;
private final static int DELAY = 1;
private final static int CYCLE_DELAY = DELAY;
private final static long MIN_MEASURE_TIME_NS = 1000L * 1000 * 1000 * TIME_SCALE; // 1s min
private final static long MAX_MEASURE_TIME_NS = 6000L * 1000 * 1000 * TIME_SCALE; // 6s max
private final static int MAX_FRAME_CYCLES = 1000 * TIME_SCALE / CYCLE_DELAY;
private final static int COLOR_TOLERANCE = 10;
private final static Color[] MARKER = {Color.RED, Color.BLUE, Color.GREEN};
private final static Toolkit TOOLKIT = Toolkit.getDefaultToolkit();
private final static long FRAME_MAX = 60;
private final static long FRAME_PREC_IN_NANOS = (1000L * 1000 * 1000) / (2L * FRAME_MAX);
interface Configurable {
void configure(Graphics2D g2d, boolean enabled);
}
final static class ConfigurableAA implements Configurable {
@Override
public void configure(final Graphics2D g2d, final boolean enabled) {
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
enabled ? RenderingHints.VALUE_ANTIALIAS_ON
: RenderingHints.VALUE_ANTIALIAS_OFF);
}
}
final static class ConfigurableTextAA implements Configurable {
@Override
public void configure(final Graphics2D g2d, final boolean enabled) {
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
enabled ? RenderingHints.VALUE_TEXT_ANTIALIAS_ON
: RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
}
}
final static class ConfigurableTextLCD implements Configurable {
@Override
public void configure(final Graphics2D g2d, final boolean enabled) {
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
enabled ? RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB
: RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
}
}
final static class ConfigurableXORMode implements Configurable {
@Override
public void configure(final Graphics2D g2d, final boolean enabled) {
if (enabled) {
g2d.setXORMode(Color.WHITE);
} else {
g2d.setPaintMode();
}
}
}
final static class ConfigurableXORModeTextLCD implements Configurable {
@Override
public void configure(final Graphics2D g2d, final boolean enabled) {
if (enabled) {
g2d.setXORMode(Color.WHITE);
} else {
g2d.setPaintMode();
}
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
enabled ? RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB
: RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);
}
}
final static class Particles {
private final float[] bx;
private final float[] by;
private final float[] vx;
private final float[] vy;
private final float r;
private final int n;
private final float x0;
private final float y0;
private final float width;
private final float height;
Particles(int n, float r, float x0, float y0, float width, float height) {
bx = new float[n];
by = new float[n];
vx = new float[n];
vy = new float[n];
this.n = n;
this.r = r;
this.x0 = x0;
this.y0 = y0;
this.width = width;
this.height = height;
for (int i = 0; i < n; i++) {
bx[i] = (float) (x0 + r + 0.1 + Math.random() * (width - 2 * r - 0.2 - x0));
by[i] = (float) (y0 + r + 0.1 + Math.random() * (height - 2 * r - 0.2 - y0));
vx[i] = 0.1f * (float) (Math.random() * 2 * r - r);
vy[i] = 0.1f * (float) (Math.random() * 2 * r - r);
}
}
void render(Graphics2D g2d, ParticleRenderer renderer) {
for (int i = 0; i < n; i++) {
renderer.render(g2d, i, bx, by, vx, vy);
}
}
void update() {
for (int i = 0; i < n; i++) {
bx[i] += vx[i];
if (bx[i] + r > width || bx[i] - r < x0) vx[i] = -vx[i];
by[i] += vy[i];
if (by[i] + r > height || by[i] - r < y0) vy[i] = -vy[i];
}
}
}
interface Renderable {
void setup(Graphics2D g2d, boolean enabled);
void render(Graphics2D g2d);
void update();
}
final static class ParticleRenderable implements Renderable {
final Particles balls;
final ParticleRenderer renderer;
Configurable configure = null;
ParticleRenderable(final Particles balls, final ParticleRenderer renderer) {
this.balls = balls;
this.renderer = renderer;
}
@Override
public void setup(final Graphics2D g2d, final boolean enabled) {
if (configure != null) {
if (TRACE_CONFIGURE) {
System.out.println("configure(" + configure.getClass().getSimpleName() + "): " + enabled);
}
configure.configure(g2d, enabled);
}
}
@Override
public void render(Graphics2D g2d) {
balls.render(g2d, renderer);
}
@Override
public void update() {
balls.update();
}
public ParticleRenderable configure(final Configurable configure) {
this.configure = configure;
return this;
}
}
interface ParticleRenderer {
void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy);
}
final static class CalibrationParticleRenderer implements ParticleRenderer {
CalibrationParticleRenderer() {
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
// no-op
}
}
final static class MixedParticleRenderer implements ParticleRenderer {
private final ParticleRenderer[] renderers;
MixedParticleRenderer(ParticleRenderer... renderers) {
this.renderers = renderers;
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
renderers[id % renderers.length].render(g2d, id, x, y, vx, vy);
}
}
final static class BatchedParticleRenderer implements ParticleRenderer {
private final ParticleRenderer[] renderers;
BatchedParticleRenderer(ParticleRenderer... renderers) {
this.renderers = renderers;
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
final int step = N / renderers.length;
renderers[(id / step) % renderers.length].render(g2d, id, x, y, vx, vy);
}
}
static class FlatParticleRenderer implements ParticleRenderer {
Color[] colors;
float r;
FlatParticleRenderer(int n, float r) {
colors = new Color[n];
this.r = r;
for (int i = 0; i < n; i++) {
colors[i] = new Color((float) Math.random(),
(float) Math.random(), (float) Math.random());
}
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.setColor(colors[id % colors.length]);
g2d.fillOval((int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r));
}
}
static class ClipFlatParticleRenderer extends FlatParticleRenderer {
ClipFlatParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
if ((id % 10) == 0) {
g2d.setColor(colors[id % colors.length]);
g2d.setClip(new Ellipse2D.Double((int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r)));
g2d.fillRect((int) (x[id] - 2 * r), (int) (y[id] - 2 * r), (int) (4 * r), (int) (4 * r));
}
}
}
static class WhiteTextParticleRenderer implements ParticleRenderer {
final float r;
final Font font;
WhiteTextParticleRenderer(float r) {
this(r, TEXT_SIZE_DEFAULT);
}
WhiteTextParticleRenderer(float r, int fontSize) {
this.r = r;
font = new Font(TEXT_FONT, Font.PLAIN, fontSize);
}
void setPaint(Graphics2D g2d, int id) {
g2d.setColor(Color.WHITE);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
setPaint(g2d, id);
g2d.setFont(font);
g2d.drawString(TEXT_STR, (int) (x[id] - r), (int) (y[id] - r));
g2d.drawString(TEXT_STR, (int) (x[id] - r), (int) y[id]);
g2d.drawString(TEXT_STR, (int) (x[id] - r), (int) (y[id] + r));
}
}
static class TextParticleRenderer extends WhiteTextParticleRenderer {
Color[] colors;
float r;
TextParticleRenderer(int n, float r) {
this(n,r, TEXT_SIZE_DEFAULT);
}
TextParticleRenderer(int n, float r, int fontSize) {
super(r, fontSize);
colors = new Color[n];
this.r = r;
for (int i = 0; i < n; i++) {
colors[i] = new Color((float) Math.random(),
(float) Math.random(), (float) Math.random());
}
}
void setPaint(Graphics2D g2d, int id) {
g2d.setColor(colors[id % colors.length]);
}
}
static class LargeTextParticleRenderer extends TextParticleRenderer {
LargeTextParticleRenderer(int n, float r) {
super(n, r, TEXT_SIZE_LARGE);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
if (id % 100 != 0) return;
super.render(g2d, id, x, y, vx, vy);
}
}
static class FlatOvalRotParticleRenderer extends FlatParticleRenderer {
FlatOvalRotParticleRenderer(int n, float r) {
super(n, r);
}
void setPaint(Graphics2D g2d, int id) {
g2d.setColor(colors[id % colors.length]);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
setPaint(g2d, id);
if (Math.abs(vx[id] + vy[id]) > 0.001) {
AffineTransform t = (AffineTransform) g2d.getTransform().clone();
double l = vx[id] / Math.sqrt(vx[id] * vx[id] + vy[id] * vy[id]);
if (vy[id] < 0) {
l = -l;
}
g2d.translate(x[id], y[id]);
g2d.rotate(Math.acos(l));
g2d.fillOval(-(int) r, (int) (-0.5 * r), (int) (2 * r), (int) r);
g2d.setTransform(t);
} else {
g2d.fillOval((int) (x[id] - r), (int) (y[id] - 0.5 * r),
(int) (2 * r), (int) r);
}
}
}
static class LinGradOvalRotParticleRenderer extends FlatOvalRotParticleRenderer {
LinGradOvalRotParticleRenderer(int n, float r) {
super(n, r);
}
@Override
void setPaint(Graphics2D g2d, int id) {
Point2D start = new Point2D.Double(-r, -0.5 * r);
Point2D end = new Point2D.Double(2 * r, r);
float[] dist = {0.0f, 1.0f};
Color[] cls = {colors[id % colors.length], colors[(colors.length - id) % colors.length]};
LinearGradientPaint p = new LinearGradientPaint(start, end, dist, cls);
g2d.setPaint(p);
}
}
static class LinGrad3OvalRotParticleRenderer extends FlatOvalRotParticleRenderer {
LinGrad3OvalRotParticleRenderer(int n, float r) {
super(n, r);
}
@Override
void setPaint(Graphics2D g2d, int id) {
Point2D start = new Point2D.Double(-r, -0.5 * r);
Point2D end = new Point2D.Double(2 * r, r);
float[] dist = {0.0f, 0.5f, 1.0f};
Color[] cls = {
colors[id % colors.length],
colors[(colors.length - id) % colors.length],
colors[(id * 5) % colors.length]};
LinearGradientPaint p = new LinearGradientPaint(start, end, dist, cls);
g2d.setPaint(p);
}
}
static class RadGrad3OvalRotParticleRenderer extends FlatOvalRotParticleRenderer {
RadGrad3OvalRotParticleRenderer(int n, float r) {
super(n, r);
}
@Override
void setPaint(Graphics2D g2d, int id) {
Point2D start = new Point2D.Double();
float[] dist = {0.0f, 0.5f, 1.0f};
Color[] cls = {
colors[id % colors.length],
colors[(colors.length - id) % colors.length],
colors[(id * 5) % colors.length]};
RadialGradientPaint p = new RadialGradientPaint(start, r, dist, cls);
g2d.setPaint(p);
}
}
static class FlatBoxParticleRenderer extends FlatParticleRenderer {
FlatBoxParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.setColor(colors[id % colors.length]);
g2d.fillRect((int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r));
}
}
static class ClipFlatBoxParticleRenderer extends FlatParticleRenderer {
ClipFlatBoxParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
if ((id % 10) == 0) {
g2d.setColor(colors[id % colors.length]);
g2d.setClip((int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r));
g2d.fillRect((int) (x[id] - 2 * r), (int) (y[id] - 2 * r), (int) (4 * r), (int) (4 * r));
}
}
}
static class ImgParticleRenderer extends FlatParticleRenderer {
BufferedImage dukeImg;
ImgParticleRenderer(int n, float r) {
super(n, r);
try {
dukeImg = ImageIO.read(
Objects.requireNonNull(
RenderPerfTest.class.getClassLoader().getResourceAsStream(
"renderperf/images/duke.png")));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.setColor(colors[id % colors.length]);
g2d.drawImage(dukeImg, (int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r), null);
}
}
static class VolImgParticleRenderer extends ImgParticleRenderer {
VolatileImage volImg;
VolImgParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
GraphicsConfiguration config = g2d.getDeviceConfiguration();
if (volImg == null) {
volImg = config.createCompatibleVolatileImage(dukeImg.getWidth(), dukeImg.getHeight(),
Transparency.TRANSLUCENT);
Graphics2D g = volImg.createGraphics();
g.setComposite(AlphaComposite.Src);
g.drawImage(dukeImg, null, null);
g.dispose();
} else {
int status = volImg.validate(config);
if (status == VolatileImage.IMAGE_INCOMPATIBLE) {
volImg = config.createCompatibleVolatileImage(dukeImg.getWidth(), dukeImg.getHeight(),
Transparency.TRANSLUCENT);
}
if (status != VolatileImage.IMAGE_OK) {
Graphics2D g = volImg.createGraphics();
g.setComposite(AlphaComposite.Src);
g.drawImage(dukeImg, null, null);
g.dispose();
}
}
Composite savedComposite = g2d.getComposite();
g2d.setComposite(AlphaComposite.SrcOver);
g2d.drawImage(volImg, (int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r), null);
g2d.setComposite(savedComposite);
}
}
static class FlatBoxRotParticleRenderer extends FlatParticleRenderer {
FlatBoxRotParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.setColor(colors[id % colors.length]);
if (Math.abs(vx[id] + vy[id]) > 0.001) {
AffineTransform t = (AffineTransform) g2d.getTransform().clone();
double l = vx[id] / Math.sqrt(vx[id] * vx[id] + vy[id] * vy[id]);
if (vy[id] < 0) {
l = -l;
}
g2d.translate(x[id], y[id]);
g2d.rotate(Math.acos(l));
g2d.fillRect(-(int) r, -(int) r, (int) (2 * r), (int) (2 * r));
g2d.setTransform(t);
} else {
g2d.fillRect((int) (x[id] - r), (int) (y[id] - r),
(int) (2 * r), (int) (2 * r));
}
}
}
static class WiredParticleRenderer extends FlatParticleRenderer {
WiredParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.setColor(colors[id % colors.length]);
g2d.drawOval((int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r));
}
}
static class WiredBoxParticleRenderer extends FlatParticleRenderer {
WiredBoxParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.setColor(colors[id % colors.length]);
g2d.drawRect((int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r));
}
}
static class SegParticleRenderer extends FlatParticleRenderer {
SegParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
double v = Math.sqrt(vx[id] * vx[id] + vy[id] * vy[id]);
float nvx = (float) (vx[id] / v);
float nvy = (float) (vy[id] / v);
g2d.setColor(colors[id % colors.length]);
g2d.drawLine((int) (x[id] - r * nvx), (int) (y[id] - r * nvy),
(int) (x[id] + 2 * r * nvx), (int) (y[id] + 2 * r * nvy));
}
}
static class WiredQuadParticleRenderer extends FlatParticleRenderer {
WiredQuadParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
if (id > 2 && (id % 3) == 0) {
g2d.setColor(colors[id % colors.length]);
g2d.draw(new QuadCurve2D.Float(x[id - 3], y[id - 3], x[id - 2], y[id - 2], x[id - 1], y[id - 1]));
}
}
}
static class FlatQuadParticleRenderer extends FlatParticleRenderer {
FlatQuadParticleRenderer(int n, float r) {
super(n, r);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
if (id > 2 && (id % 3) == 0) {
g2d.setColor(colors[id % colors.length]);
g2d.fill(new QuadCurve2D.Float(x[id - 3], y[id - 3], x[id - 2], y[id - 2], x[id - 1], y[id - 1]));
}
}
}
static class BlitImageParticleRenderer extends FlatParticleRenderer {
BufferedImage image;
BlitImageParticleRenderer(int n, float r, BufferedImage img) {
super(n, r);
image = img;
fill(image);
}
@Override
public void render(Graphics2D g2d, int id, float[] x, float[] y, float[] vx, float[] vy) {
g2d.drawImage(image, (int) (x[id] - r), (int) (y[id] - r), (int) (2 * r), (int) (2 * r), null);
}
private static void fill(final Image image) {
final Graphics2D graphics = (Graphics2D) image.getGraphics();
graphics.setComposite(AlphaComposite.Src);
for (int i = 0; i < image.getHeight(null); ++i) {
graphics.setColor(new Color(i, 0, 0));
graphics.fillRect(0, i, image.getWidth(null), 1);
}
graphics.dispose();
}
}
static class SwBlitImageParticleRenderer extends BlitImageParticleRenderer {
SwBlitImageParticleRenderer(int n, float r, final int type) {
super(n, r, makeUnmanagedBI(type));
}
private static BufferedImage makeUnmanagedBI(final int type) {
final BufferedImage bi = new BufferedImage(17, 33, type);
final DataBuffer db = bi.getRaster().getDataBuffer();
if (db instanceof DataBufferInt) {
((DataBufferInt) db).getData();
} else if (db instanceof DataBufferShort) {
((DataBufferShort) db).getData();
} else if (db instanceof DataBufferByte) {
((DataBufferByte) db).getData();
}
bi.setAccelerationPriority(0.0f);
return bi;
}
}
static class SurfaceBlitImageParticleRenderer extends BlitImageParticleRenderer {
SurfaceBlitImageParticleRenderer(int n, float r, final int type) {
super(n, r, makeManagedBI(type));
}
private static BufferedImage makeManagedBI(final int type) {
final BufferedImage bi = new BufferedImage(17, 33, type);
bi.setAccelerationPriority(1.0f);
return bi;
}
}
final static class PerfMeter {
private final FrameHandler fh;
private final String name;
private final PerfMeterExecutor executor;
PerfMeter(final FrameHandler fh, String name) {
this.fh = fh;
this.name = name;
executor = getExecutor();
}
void exec(final Renderable renderable) throws Exception {
executor.exec(name, renderable);
}
private PerfMeterExecutor getExecutor() {
switch (EXEC_MODE) {
default:
case EXEC_MODE_ROBOT:
return new PerfMeterRobot(fh);
case EXEC_MODE_BUFFER:
fh.prepareImageProvider(false);
return new PerfMeterImageProvider(fh);
case EXEC_MODE_VOLATILE:
fh.prepareImageProvider(true);
return new PerfMeterImageProvider(fh);
}
}
}
static void paintTest(final Renderable renderable, final Graphics2D g2d,
final Color markerColor, final boolean doSync) {
// clip to frame:
g2d.setClip(0, 0, IMAGE_W, IMAGE_H);
// clear background:
g2d.setColor(Color.BLACK);
g2d.fillRect(0, 0, IMAGE_W, IMAGE_H);
// render test:
renderable.setup(g2d, true);
renderable.render(g2d);
renderable.setup(g2d, false);
// draw marker at end:
g2d.setClip(0, 0, BW, BH);
g2d.setColor(markerColor);
g2d.fillRect(0, 0, BW, BH);
if (doSync) {
// synchronize toolkit:
TOOLKIT.sync();
}
}
final static class FrameHandler {
private boolean calibrate = VERBOSE;
private int threadId = -1;
private int frameId = -1;
private final GraphicsConfiguration gc;
private JFrame frame = null;
private final CountDownLatch latchShownFrame = new CountDownLatch(1);
private final CountDownLatch latchClosedFrame = new CountDownLatch(1);
private ImageProvider imageProvider = null;
FrameHandler(GraphicsConfiguration gc) {
this.gc = gc;
}
void setIds(int threadId, int frameId) {
this.threadId = threadId;
this.frameId = frameId;
}
void prepareFrameEDT(final String title) {
if (frame == null) {
frame = new JFrame(gc);
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.addComponentListener(new ComponentAdapter() {
@Override
public void componentShown(ComponentEvent e) {
latchShownFrame.countDown();
}
});
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosed(WindowEvent e) {
latchClosedFrame.countDown();
}
});
}
frame.setTitle(title);
}
void showFrameEDT(final JPanel panel) {
if (frame != null) {
panel.setPreferredSize(new Dimension(IMAGE_W, IMAGE_H));
panel.setBackground(Color.BLACK);
frame.getContentPane().removeAll();
frame.getContentPane().add(panel);
frame.getContentPane().revalidate();
if (!frame.isVisible()) {
if (frameId != -1) {
final int off = (frameId - 1) * 100;
final Rectangle gcBounds = gc.getBounds();
final int xoff = gcBounds.x + off;
final int yoff = gcBounds.y + off;
if ((xoff != 0) || (yoff != 0)) {
frame.setLocation(xoff, yoff);
}
}
frame.pack();
frame.setVisible(true);
}
}
}
void waitFrameShown() throws Exception {
latchShownFrame.await();
}
void resetFrame() throws Exception {
if (frame != null) {
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
frame.getContentPane().removeAll();
frame.getContentPane().revalidate();
}
});
}
}
void repaintFrame() throws Exception {
if (frame != null) {
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
frame.repaint();
}
});
}
}
private void waitFrameHidden() throws Exception {
latchClosedFrame.await();
}
void hideFrameAndWait() throws Exception {
if (frame != null) {
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
frame.setVisible(false);
frame.dispose();
frame = null;
}
});
waitFrameHidden();
}
}
void prepareImageProvider(final boolean useVolatile) {
if (this.imageProvider == null) {
this.imageProvider = new ImageProvider(useVolatile);
}
}
}
static abstract class PerfMeterExecutor {
protected final static int SCORE_MAIN = 0;
protected final static int SCORE_ERROR = 1;
protected final static int SCORE_OTHER = 2;
protected final static int PCT_00 = 0;
protected final static int PCT_10 = 1;
protected final static int PCT_25 = 2;
protected final static int PCT_50 = 3;
protected final static int PCT_75 = 4;
protected final static int PCT_90 = 5;
protected final static int PCT_100 = 6;
private final static IntBinaryOperator INC_MOD_FUNC = new IntBinaryOperator() {
public int applyAsInt(int x, int y) {
return (x + 1) % y;
}
};
private static final AtomicInteger headerMark = new AtomicInteger(1);
/* members */
protected final FrameHandler fh;
protected final boolean skipWait;
protected final AtomicInteger paintIdx = new AtomicInteger(0);
protected final AtomicInteger markerIdx = new AtomicInteger(0);
protected final AtomicLong markerStartTime = new AtomicLong(0);
protected final AtomicLong markerPaintTime = new AtomicLong(0);
protected String name = null;
protected int skippedFrames = 0;
protected int frames = 0;
// test timestamp data:
protected long[] testTimestamp = new long[MAX_SAMPLE_COUNT];
// test duration data (ns):
protected long[] testTime = new long[MAX_SAMPLE_COUNT];
protected final double[] scores = new double[SCORE_OTHER + 1];
protected final double[] results = new double[PCT_100 + 1];
protected PerfMeterExecutor(final boolean skipWait, final FrameHandler fh) {
this.skipWait = skipWait;
this.fh = fh;
}
protected void beforeExec() {
}
protected void afterExec() {
}
protected void reset() {
paintIdx.set(0);
markerIdx.set(0);
markerStartTime.set(0);
markerPaintTime.set(0);
}
protected void updateMarkerIdx() {
markerIdx.accumulateAndGet(MARKER.length, INC_MOD_FUNC);
}
protected final void exec(final String testName, final Renderable renderable) throws Exception {
if (TRACE) System.out.print("\n!");
this.name = testName + (isMultiThreads() ? ("-" + fh.threadId) : "");
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
fh.prepareFrameEDT(name);
// call beforeExec() after frame is created:
beforeExec();
final JPanel panel = new JPanel() {
@Override
protected void paintComponent(Graphics g) {
if (TRACE) System.out.print("P");
paintPanel(renderable, g);
if (TRACE) System.out.print("Q");
}
};
fh.showFrameEDT(panel);
if (TRACE) System.out.print(">>");
}
});
// Wait frame to be shown:
fh.waitFrameShown();
if (TRACE) System.out.print(":");
// Reset before warmup:
reset();
if (WARMUP_COUNT > 0) {
// Warmup to prepare frame synchronization:
for (int i = 0; i < WARMUP_COUNT; i++) {
updateMarkerIdx();
renderable.update();
fh.repaintFrame();
sleep(10);
while (markerStartTime.get() == 0) {
if (TRACE) System.out.print("-");
sleep(1);
}
markerStartTime.set(0);
}
// Reset before measurements:
reset();
}
if (TRACE) System.out.print(":>>");
// signal thread is ready for test
readyCount.countDown();
if (TRACE_SYNC) traceSync(name + " ready => waiting start signal...");
// wait start signal:
triggerStart.await();
// Run Benchmark (all threads):
if (TRACE_SYNC) traceSync(name + " benchmark started");
int cycles = 0;
frames = 0;
long paintStartTime = 0L;
long paintElapsedTime = 0L;
long lastFrameTime = 0L;
final long startTime = System.nanoTime();
final long minTime = startTime + MIN_MEASURE_TIME_NS;
final long endTime = startTime + MAX_MEASURE_TIME_NS;
// Start 1st measurement:
fh.repaintFrame();
for (; ; ) {
long t;
if ((t = markerStartTime.getAndSet(0L)) > 0L) {
paintStartTime = t;
if (TRACE) System.out.print("|");
}
boolean wait = true;
if (paintStartTime > 0L) {
// get optional elapsed time:
paintElapsedTime = markerPaintTime.get();
if (TRACE) System.out.print(".");
wait = !skipWait;
final Color c = getMarkerColor();
if (isAlmostEqual(c, MARKER[markerIdx.get()])) {
final long durationNs = getElapsedTime((paintElapsedTime != 0L) ? paintElapsedTime : paintStartTime);
if ((durationNs > 0L) && (frames < MAX_SAMPLE_COUNT)) {
testTimestamp[frames] = paintStartTime - startTime;
testTime[frames] = durationNs;
}
if (REPORT_OVERALL_FPS) {
lastFrameTime = System.nanoTime();
}
if (TRACE) System.out.print("R");
frames++;
paintStartTime = 0L;
paintElapsedTime = 0L;
cycles = 0;
updateMarkerIdx();
renderable.update();
fh.repaintFrame();
} else if (cycles >= MAX_FRAME_CYCLES) {
if (TRACE) System.out.print("M");
skippedFrames++;
paintStartTime = 0L;
paintElapsedTime = 0L;
cycles = 0;
updateMarkerIdx();
fh.repaintFrame();
} else {
if (TRACE) System.out.print("-");
}
}
final long currentTime = System.nanoTime();
if ((frames >= MIN_COUNT) && (currentTime >= endTime)) {
break;
}
if ((frames >= COUNT) && (currentTime >= minTime)) {
break;
}
if (wait) {
sleep(CYCLE_DELAY);
}
cycles++;
} // end measurements
// signal test completed:
completedCount.countDown();
if (TRACE_SYNC) traceSync(name + " completed => waiting stop signal...");
// wait stop signal:
triggerStop.await();
// Stop Benchmark (all threads):
if (TRACE_SYNC) traceSync(name + " stopped");
if (DELAY_TEST) {
sleep(1000);
}
fh.resetFrame();
// Process results:
if (REPORT_OVERALL_FPS && (lastFrameTime != 0)) {
final double elapsedTime = (lastFrameTime - startTime);
final double elapsedFPS = 1000000000.0 * frames / elapsedTime;
System.err.println(frames + " in " + (elapsedTime / 1000000) + " ms: ~ " + elapsedFPS + " FPS");
}
processTimes();
if (TRACE) System.out.print("<<\n");
afterExec();
// Log header once:
if (headerMark.getAndDecrement() == 1) {
System.err.println(getHeader());
}
// Log report:
System.err.println(getResults());
// signal test done:
doneCount.countDown();
if (TRACE_SYNC) traceSync(name + " done => waiting exit signal...");
// wait exit signal:
triggerExit.await();
// Stop Benchmark (all threads):
if (TRACE_SYNC) traceSync(name + " exited");
}
protected abstract void paintPanel(final Renderable renderable, final Graphics g);
protected abstract long getElapsedTime(long paintTime);
protected abstract Color getMarkerColor() throws Exception;
protected boolean isAlmostEqual(Color c1, Color c2) {
return (Math.abs(c1.getRed() - c2.getRed()) < COLOR_TOLERANCE) &&
(Math.abs(c1.getGreen() - c2.getGreen()) < COLOR_TOLERANCE) &&
(Math.abs(c1.getBlue() - c2.getBlue()) < COLOR_TOLERANCE);
}
protected void processTimes() {
if (frames != 0) {
frames = Math.min(frames, MAX_SAMPLE_COUNT);
if (DUMP_SAMPLES) {
// Dump all results:
final File file = new File("./rp-" + replaceNonFileNameChars(name) + "-samples.csv");
System.out.println("Writing samples to : " + file.getAbsolutePath());
try (final PrintWriter w = new PrintWriter(file, Charset.forName("UTF-8"))) {
w.write("# ");
w.write(VERSION);
w.write(" - ");
w.write("Test: ");
w.write(name);
w.write('\n');
for (int i = 0; i < frames; i++) {
w.write(Double.toString(millis(testTimestamp[i])));
w.write(',');
w.write(Double.toString(millis(testTime[i])));
w.write('\n');
}
} catch (IOException ioe) {
System.err.println("IO exception:");
ioe.printStackTrace();
}
}
// Ignore first 10% (warmup at the beginning):
final int first = (int) Math.floor(frames * 0.10);
final int last = frames - 1;
// free testTimestamp to avoid any future usage:
testTimestamp = null;
// note: testTime array is modified below:
// Sort values to get percentiles:
Arrays.sort(testTime, first, frames);
final long[] pcts = getPercentiles(testTime, first, last);
final long median = pcts[PCT_50];
if (USE_FPS) {
scores[SCORE_MAIN] = fps(median);
results[PCT_100] = fps(pcts[PCT_00]);
results[PCT_90] = fps(pcts[PCT_10]);
results[PCT_75] = fps(pcts[PCT_25]);
results[PCT_50] = fps(pcts[PCT_50]);
results[PCT_25] = fps(pcts[PCT_75]);
results[PCT_10] = fps(pcts[PCT_90]);
results[PCT_00] = fps(pcts[PCT_100]);
// STDDEV = IQR / 1.35 = (Q3 - Q1) * 20 / 27
scores[SCORE_ERROR] = (results[PCT_75] - results[PCT_25]) * 20L / 27L;
scores[SCORE_OTHER] = millis(median);
} else {
scores[SCORE_MAIN] = millis(median);
results[PCT_00] = millis(pcts[PCT_00]);
results[PCT_10] = millis(pcts[PCT_10]);
results[PCT_25] = millis(pcts[PCT_25]);
results[PCT_50] = millis(pcts[PCT_50]);
results[PCT_75] = millis(pcts[PCT_75]);
results[PCT_90] = millis(pcts[PCT_90]);
results[PCT_100] = millis(pcts[PCT_100]);
// STDDEV = IQR / 1.35 = (Q3 - Q1) * 20 / 27 (normal distribution ?)
scores[SCORE_ERROR] = (results[PCT_75] - results[PCT_25]) * 20L / 27L;
scores[SCORE_OTHER] = fps(median);
// System.out.println("stddev(IQR) = " + scores[SCORE_ERROR]);
// MAD = Median Absolute Deviation:
for (int i = first; i <= last; i++) {
testTime[i] = Math.abs(testTime[i] - median);
}
// Sort values to get percentiles:
Arrays.sort(testTime, first, frames);
// STDDEV = 1.4826 * MAD (normal distribution ?)
scores[SCORE_ERROR] = 1.4826 * millis(testTime[pctIndex(first, last, 0.50)]); // 50% (median)
// System.out.println("stddev(MAD) = " + scores[SCORE_ERROR]);
}
// free testTime to avoid any future usage:
testTime = null;
}
}
protected static String getHeader() {
if (VERBOSE) {
return String.format("%-25s : %s ± %s %s [%s] (p00: ... p10: ... p25: ... p50: ... p75: ... p90: ... p100: ... %s) (... frames)",
"Test Name", (USE_FPS ? "Median(FPS)" : "Median(TimeMs)"), (USE_FPS ? "Stddev(FPS)" : "Stddev(TimeMs)"), "Unit",
(!USE_FPS ? "Median(FPS)" : "Median(TimeMs)"), "Unit");
}
return String.format("%-25s : %s ± %s %s",
"Test Name", (USE_FPS ? "Median(FPS)" : "Median(TimeMs)"), (USE_FPS ? "Stddev(FPS)" : "Stddev(TimeMs)"), "Unit");
}
protected String getResults() {
if (skippedFrames > 0) {
System.err.println(name + " : " + skippedFrames + " frame(s) skipped");
}
if (VERBOSE) {
return String.format("%-25s : %.3f ± %.3f %s [%.3f %s] (p00: %.3f p10: %.3f p25: %.3f p50: %.3f p75: %.3f p90: %.3f p100: %.3f %s) (%d frames)",
name, scores[SCORE_MAIN], scores[SCORE_ERROR], (USE_FPS ? "FPS" : "ms"),
scores[SCORE_OTHER], (USE_FPS ? "ms" : "FPS"),
results[PCT_00], results[PCT_10], results[PCT_25], results[PCT_50], results[PCT_75], results[PCT_90], results[PCT_100],
(USE_FPS ? "FPS" : "ms"),
frames);
}
return String.format("%-25s : %.3f ± %.3f %s",
name, scores[SCORE_MAIN], scores[SCORE_ERROR], (USE_FPS ? "FPS" : "ms"));
}
protected double fps(long timeNs) {
return 1e9 / timeNs;
}
protected double millis(long timeNs) {
return 1e-6 * timeNs;
}
protected static long[] getPercentiles(final long[] data, final int first, final int last) {
final long[] pcts = new long[PCT_100 + 1];
pcts[PCT_00] = data[first]; // 0% (min)
pcts[PCT_10] = data[pctIndex(first, last, 0.10)]; // 10%
pcts[PCT_25] = data[pctIndex(first, last, 0.25)]; // 25% (Q1)
pcts[PCT_50] = data[pctIndex(first, last, 0.50)]; // 50% (Median)
pcts[PCT_75] = data[pctIndex(first, last, 0.75)]; // 75% (Q3)
pcts[PCT_90] = data[pctIndex(first, last, 0.90)]; // 90%
pcts[PCT_100] = data[pctIndex(first, last, 1.00)]; // 100% (max)
return pcts;
}
protected static int pctIndex(final int min, final int last, final double pct) {
return min + (int) Math.round((last - min) * pct);
}
}
final static class PerfMeterRobot extends PerfMeterExecutor {
private int nRobotTimes = 0;
private long[] robotTime = (fh.calibrate) ? new long[COUNT] : null;
private int nDelayTimes = 0;
private long[] delayTime = (ROBOT_TIME_DELAY) ? null : new long[COUNT];
private long lastPaintTime = 0L;
private int renderedMarkerIdx = -1;
private Robot robot = null;
PerfMeterRobot(final FrameHandler fh) {
super(true, fh);
}
protected void beforeExec() {
try {
robot = new Robot();
} catch (AWTException ae) {
throw new RuntimeException(ae);
}
}
protected void reset() {
super.reset();
nRobotTimes = 0;
nDelayTimes = 0;
lastPaintTime = 0L;
renderedMarkerIdx = -1;
}
protected void paintPanel(final Renderable renderable, final Graphics g) {
final int idx = markerIdx.get();
final long start = System.nanoTime();
final Graphics2D g2d = (Graphics2D) g.create();
try {
paintTest(renderable, g2d, MARKER[idx], false);
} finally {
g2d.dispose();
}
// Update paintIdx:
paintIdx.incrementAndGet();
// publish start time:
if (idx != renderedMarkerIdx) {
renderedMarkerIdx = idx;
markerStartTime.set(start);
}
}
protected long getElapsedTime(final long paintTime) {
final long now = System.nanoTime();
long duration = (!ROBOT_TIME_DELAY) ? roundDuration(now - paintTime) : 0L;
if (lastPaintTime != 0L) {
final long delay = roundDuration(now - lastPaintTime);
if (ROBOT_TIME_DELAY) {
duration = delay;
} else if (nDelayTimes < COUNT) {
delayTime[nDelayTimes++] = delay;
}
}
lastPaintTime = now;
return duration;
}
private static long roundDuration(final long durationNs) {
return (durationNs <= 0L) ? 0L : (
(ROBOT_TIME_ROUND) ?
FRAME_PREC_IN_NANOS * (long) Math.rint(((double) durationNs) / FRAME_PREC_IN_NANOS) : durationNs
);
}
protected Color getMarkerColor() {
final Point frameOffset = fh.frame.getLocationOnScreen();
final Insets insets = fh.frame.getInsets();
final int px = frameOffset.x + insets.left + BW / 2;
final int py = frameOffset.y + insets.top + BH / 2;
final long beforeRobot = (fh.calibrate) ? System.nanoTime() : 0L;
final Color c = robot.getPixelColor(px, py);
if ((fh.calibrate) && (nRobotTimes < COUNT)) {
robotTime[nRobotTimes++] = System.nanoTime() - beforeRobot;
}
return c;
}
protected String getResults() {
if (fh.calibrate && (nRobotTimes != 0)) {
fh.calibrate = false; // only first time
Arrays.sort(robotTime);
final long[] pcts = getPercentiles(robotTime, 0, nRobotTimes - 1);
// free testTime to avoid any future usage:
testTime = null;
System.err.printf("%-25s : %.3f ms (p00: %.3f p10: %.3f p25: %.3f p50: %.3f p75: %.3f p90: %.3f p100: %.3f ms) (%d times)%n",
"Robot" + (isMultiThreads() ? ("-" + fh.threadId) : ""), millis(pcts[PCT_50]),
millis(pcts[PCT_00]), millis(pcts[PCT_10]), millis(pcts[PCT_25]), millis(pcts[PCT_50]),
millis(pcts[PCT_75]), millis(pcts[PCT_90]), millis(pcts[PCT_100]), nRobotTimes);
}
if (nDelayTimes != 0) {
Arrays.sort(delayTime);
final long[] pcts = getPercentiles(robotTime, 0, nDelayTimes - 1);
// free delayTime to avoid any future usage:
delayTime = null;
System.err.printf("%-25s : %.3f ms [%.3f FPS] (p00: %.3f p10: %.3f p25: %.3f p50: %.3f p75: %.3f p90: %.3f p100: %.3f ms) (%d times)%n",
"DelayTime-" + name + (isMultiThreads() ? ("-" + fh.threadId) : ""), millis(pcts[PCT_50]), fps(pcts[PCT_50]),
millis(pcts[PCT_00]), millis(pcts[PCT_10]), millis(pcts[PCT_25]), millis(pcts[PCT_50]),
millis(pcts[PCT_75]), millis(pcts[PCT_90]), millis(pcts[PCT_100]), nDelayTimes);
}
return super.getResults();
}
}
final static class PerfMeterImageProvider extends PerfMeterExecutor {
private final ImageProvider imageProvider;
PerfMeterImageProvider(final FrameHandler fh) {
super(false, fh);
this.imageProvider = fh.imageProvider;
}
protected void beforeExec() {
imageProvider.create(fh.frame.getGraphicsConfiguration(), IMAGE_W, IMAGE_H);
}
protected void afterExec() {
imageProvider.reset();
}
protected void paintPanel(final Renderable renderable, final Graphics g) {
// suppose image provider is ready yet
final int idx = markerIdx.get();
long start = System.nanoTime();
// Get Graphics from image provider:
final Graphics2D g2d = imageProvider.createGraphics();
try {
paintTest(renderable, g2d, MARKER[idx], true);
} finally {
g2d.dispose();
}
final long now = System.nanoTime();
// Update paintIdx:
paintIdx.incrementAndGet();
// publish start time:
markerStartTime.set(start);
// publish elapsed time:
markerPaintTime.set(now - start);
// Draw image on screen:
g.drawImage(imageProvider.getImage(), 0, 0, null);
}
protected long getElapsedTime(long paintTime) {
return paintTime;
}
protected Color getMarkerColor() {
final int px = BW / 2;
final int py = BH / 2;
return new Color(imageProvider.getSnapshot().getRGB(px, py));
}
}
private final static class ImageProvider {
private final static int TRANSPARENCY = Transparency.TRANSLUCENT;
private final boolean useVolatile;
private Image image = null;
private ImageProvider(boolean useVolatile) {
this.useVolatile = useVolatile;
}
void create(GraphicsConfiguration gc, int width, int height) {
this.image = (useVolatile) ? gc.createCompatibleVolatileImage(width, height, TRANSPARENCY)
: gc.createCompatibleImage(width, height, TRANSPARENCY);
}
public void reset() {
image = null;
}
public Image getImage() {
return image;
}
public Graphics2D createGraphics() {
return (useVolatile) ? ((VolatileImage) image).createGraphics()
: ((BufferedImage) image).createGraphics();
}
public BufferedImage getSnapshot() {
return (useVolatile) ? ((VolatileImage) image).getSnapshot()
: (BufferedImage) image;
}
}
private final FrameHandler fh;
private final Particles balls = new Particles(N, R, BW, BH, WIDTH, HEIGHT);
private final ParticleRenderer calibRenderer = new CalibrationParticleRenderer();
private final ParticleRenderer flatRenderer = new FlatParticleRenderer(N, R);
private final ParticleRenderer clipFlatRenderer = new ClipFlatParticleRenderer(N, R);
private final ParticleRenderer flatOvalRotRenderer = new FlatOvalRotParticleRenderer(N, R);
private final ParticleRenderer flatBoxRenderer = new FlatBoxParticleRenderer(N, R);
private final ParticleRenderer clipFlatBoxParticleRenderer = new ClipFlatBoxParticleRenderer(N, R);
private final ParticleRenderer flatBoxRotRenderer = new FlatBoxRotParticleRenderer(N, R);
private final ParticleRenderer linGradOvalRotRenderer = new LinGradOvalRotParticleRenderer(N, R);
private final ParticleRenderer linGrad3OvalRotRenderer = new LinGrad3OvalRotParticleRenderer(N, R);
private final ParticleRenderer radGrad3OvalRotRenderer = new RadGrad3OvalRotParticleRenderer(N, R);
private final ParticleRenderer wiredRenderer = new WiredParticleRenderer(N, R);
private final ParticleRenderer wiredBoxRenderer = new WiredBoxParticleRenderer(N, R);
private final ParticleRenderer segRenderer = new SegParticleRenderer(N, R);
private final ParticleRenderer flatQuadRenderer = new FlatQuadParticleRenderer(N, R);
private final ParticleRenderer wiredQuadRenderer = new WiredQuadParticleRenderer(N, R);
private final ParticleRenderer imgRenderer = new ImgParticleRenderer(N, R);
private final ParticleRenderer volImgRenderer = new VolImgParticleRenderer(N, R);
private final ParticleRenderer textRenderer = new TextParticleRenderer(N, R);
private final ParticleRenderer largeTextRenderer = new LargeTextParticleRenderer(N, R);
private final ParticleRenderer whiteTextRenderer = new WhiteTextParticleRenderer(R);
private final ParticleRenderer argbSwBlitImageRenderer = new SwBlitImageParticleRenderer(N, R, BufferedImage.TYPE_INT_ARGB);
private final ParticleRenderer bgrSwBlitImageRenderer = new SwBlitImageParticleRenderer(N, R, BufferedImage.TYPE_INT_BGR);
private final ParticleRenderer argbSurfaceBlitImageRenderer = new SurfaceBlitImageParticleRenderer(N, R, BufferedImage.TYPE_INT_ARGB);
private final ParticleRenderer bgrSurfaceBlitImageRenderer = new SurfaceBlitImageParticleRenderer(N, R, BufferedImage.TYPE_INT_BGR);
private final ParticleRenderer textWiredQuadBatchedRenderer = new BatchedParticleRenderer(textRenderer, wiredQuadRenderer);
private final ParticleRenderer textWiredQuadMixedRenderer = new MixedParticleRenderer(textRenderer, wiredQuadRenderer);
private final ParticleRenderer volImgFlatBoxBatchedRenderer = new BatchedParticleRenderer(volImgRenderer, flatBoxRenderer);
private final ParticleRenderer volImgFlatBoxMixedRenderer = new MixedParticleRenderer(volImgRenderer, flatBoxRenderer);
private final ParticleRenderer volImgWiredQuadBatchedRenderer = new BatchedParticleRenderer(volImgRenderer, wiredQuadRenderer);
private final ParticleRenderer volImgWiredQuadMixedRenderer = new MixedParticleRenderer(volImgRenderer, wiredQuadRenderer);
private final ParticleRenderer volImgTextBatchedRenderer = new BatchedParticleRenderer(volImgRenderer, textRenderer);
private final ParticleRenderer volImgTextMixedRenderer = new MixedParticleRenderer(volImgRenderer, textRenderer);
private final static Configurable AA = new ConfigurableAA();
private final static Configurable TextAA = new ConfigurableTextAA();
private final static Configurable TextLCD = new ConfigurableTextLCD();
private final static Configurable XORMode = new ConfigurableXORMode();
private final static Configurable XORModeLCDText = new ConfigurableXORModeTextLCD();
RenderPerfTest(final GraphicsConfiguration gc) {
fh = new FrameHandler(gc);
}
ParticleRenderable createPR(final ParticleRenderer renderer) {
return new ParticleRenderable(balls, renderer);
}
PerfMeter createPerfMeter(final String name) {
return new PerfMeter(fh, name);
}
public void testCalibration() throws Exception {
createPerfMeter(testName).exec(createPR(calibRenderer));
}
public void testFlatOval() throws Exception {
createPerfMeter(testName).exec(createPR(flatRenderer));
}
public void testFlatOvalAA() throws Exception {
createPerfMeter(testName).exec(createPR(flatRenderer).configure(AA));
}
public void testClipFlatOval() throws Exception {
createPerfMeter(testName).exec(createPR(clipFlatRenderer));
}
public void testClipFlatOvalAA() throws Exception {
createPerfMeter(testName).exec(createPR(clipFlatRenderer).configure(AA));
}
public void testFlatBox() throws Exception {
createPerfMeter(testName).exec(createPR(flatBoxRenderer));
}
public void testFlatBoxAA() throws Exception {
createPerfMeter(testName).exec(createPR(flatBoxRenderer).configure(AA));
}
public void testClipFlatBox() throws Exception {
createPerfMeter(testName).exec(createPR(clipFlatBoxParticleRenderer));
}
public void testClipFlatBoxAA() throws Exception {
createPerfMeter(testName).exec(createPR(clipFlatBoxParticleRenderer).configure(AA));
}
public void testImage() throws Exception {
createPerfMeter(testName).exec(createPR(imgRenderer));
}
public void testImageAA() throws Exception {
createPerfMeter(testName).exec(createPR(imgRenderer).configure(AA));
}
public void testVolImage() throws Exception {
createPerfMeter(testName).exec(createPR(volImgRenderer));
}
public void testVolImageAA() throws Exception {
createPerfMeter(testName).exec(createPR(volImgRenderer).configure(AA));
}
public void testRotatedBox() throws Exception {
createPerfMeter(testName).exec(createPR(flatBoxRotRenderer));
}
public void testRotatedBoxAA() throws Exception {
createPerfMeter(testName).exec(createPR(flatBoxRotRenderer).configure(AA));
}
public void testRotatedOval() throws Exception {
createPerfMeter(testName).exec(createPR(flatOvalRotRenderer));
}
public void testRotatedOvalAA() throws Exception {
createPerfMeter(testName).exec(createPR(flatOvalRotRenderer).configure(AA));
}
public void testLinGrad3RotatedOval() throws Exception {
createPerfMeter(testName).exec(createPR(linGrad3OvalRotRenderer));
}
public void testLinGrad3RotatedOvalAA() throws Exception {
createPerfMeter(testName).exec(createPR(linGrad3OvalRotRenderer).configure(AA));
}
public void testRadGrad3RotatedOval() throws Exception {
createPerfMeter(testName).exec(createPR(radGrad3OvalRotRenderer));
}
public void testRadGrad3RotatedOvalAA() throws Exception {
createPerfMeter(testName).exec(createPR(radGrad3OvalRotRenderer).configure(AA));
}
public void testLinGradRotatedOval() throws Exception {
createPerfMeter(testName).exec(createPR(linGradOvalRotRenderer));
}
public void testLinGradRotatedOvalAA() throws Exception {
createPerfMeter(testName).exec(createPR(linGradOvalRotRenderer).configure(AA));
}
public void testWiredBubbles() throws Exception {
createPerfMeter(testName).exec(createPR(wiredRenderer));
}
public void testWiredBubblesAA() throws Exception {
createPerfMeter(testName).exec(createPR(wiredRenderer).configure(AA));
}
public void testWiredBox() throws Exception {
createPerfMeter(testName).exec(createPR(wiredBoxRenderer));
}
public void testWiredBoxAA() throws Exception {
createPerfMeter(testName).exec(createPR(wiredBoxRenderer).configure(AA));
}
public void testLines() throws Exception {
createPerfMeter(testName).exec(createPR(segRenderer));
}
public void testLinesAA() throws Exception {
createPerfMeter(testName).exec(createPR(segRenderer).configure(AA));
}
public void testFlatQuad() throws Exception {
createPerfMeter(testName).exec(createPR(flatQuadRenderer));
}
public void testFlatQuadAA() throws Exception {
createPerfMeter(testName).exec(createPR(flatQuadRenderer).configure(AA));
}
public void testWiredQuad() throws Exception {
createPerfMeter(testName).exec(createPR(wiredQuadRenderer));
}
public void testWiredQuadAA() throws Exception {
createPerfMeter(testName).exec(createPR(wiredQuadRenderer).configure(AA));
}
public void testTextNoAA() throws Exception {
createPerfMeter(testName).exec(createPR(textRenderer));
}
public void testTextLCD() throws Exception {
createPerfMeter(testName).exec(createPR(textRenderer).configure(TextLCD));
}
public void testTextGray() throws Exception {
createPerfMeter(testName).exec(createPR(textRenderer).configure(TextAA));
}
public void testLargeTextNoAA() throws Exception {
createPerfMeter(testName).exec(createPR(largeTextRenderer));
}
public void testLargeTextLCD() throws Exception {
createPerfMeter(testName).exec(createPR(largeTextRenderer).configure(TextLCD));
}
public void testLargeTextGray() throws Exception {
createPerfMeter(testName).exec(createPR(largeTextRenderer).configure(TextAA));
}
public void testWhiteTextNoAA() throws Exception {
createPerfMeter(testName).exec(createPR(whiteTextRenderer));
}
public void testWhiteTextLCD() throws Exception {
createPerfMeter(testName).exec(createPR(whiteTextRenderer).configure(TextLCD));
}
public void testWhiteTextGray() throws Exception {
createPerfMeter(testName).exec(createPR(whiteTextRenderer).configure(TextAA));
}
public void testArgbSwBlitImage() throws Exception {
createPerfMeter(testName).exec(createPR(argbSwBlitImageRenderer));
}
public void testBgrSwBlitImage() throws Exception {
createPerfMeter(testName).exec(createPR(bgrSwBlitImageRenderer));
}
public void testArgbSurfaceBlitImage() throws Exception {
createPerfMeter(testName).exec(createPR(argbSurfaceBlitImageRenderer));
}
public void testBgrSurfaceBlitImage() throws Exception {
createPerfMeter(testName).exec(createPR(bgrSurfaceBlitImageRenderer));
}
// XOR mode:
public void testFlatOval_XOR() throws Exception {
createPerfMeter(testName).exec(createPR(flatRenderer).configure(XORMode));
}
public void testRotatedBox_XOR() throws Exception {
createPerfMeter(testName).exec(createPR(flatBoxRotRenderer).configure(XORMode));
}
public void testLines_XOR() throws Exception {
createPerfMeter(testName).exec(createPR(segRenderer).configure(XORMode));
}
public void testImage_XOR() throws Exception {
createPerfMeter(testName).exec(createPR(imgRenderer).configure(XORMode));
}
public void testTextNoAA_XOR() throws Exception {
createPerfMeter(testName).exec(createPR(textRenderer).configure(XORMode));
}
public void testTextLCD_XOR() throws Exception {
createPerfMeter(testName).exec(createPR(textRenderer).configure(XORModeLCDText));
}
// Mixed/Batched mode:
public void testTextWiredQuadBat() throws Exception {
createPerfMeter(testName).exec(createPR(textWiredQuadBatchedRenderer));
}
public void testTextWiredQuadMix() throws Exception {
createPerfMeter(testName).exec(createPR(textWiredQuadMixedRenderer));
}
public void testTextWiredQuadAABat() throws Exception {
createPerfMeter(testName).exec(createPR(textWiredQuadBatchedRenderer).configure(AA));
}
public void testTextWiredQuadAAMix() throws Exception {
createPerfMeter(testName).exec(createPR(textWiredQuadMixedRenderer).configure(AA));
}
public void testVolImageFlatBoxBat() throws Exception {
createPerfMeter(testName).exec(createPR(volImgFlatBoxBatchedRenderer));
}
public void testVolImageFlatBoxMix() throws Exception {
createPerfMeter(testName).exec(createPR(volImgFlatBoxMixedRenderer));
}
public void testVolImageFlatBoxAABat() throws Exception {
createPerfMeter(testName).exec(createPR(volImgFlatBoxBatchedRenderer).configure(AA));
}
public void testVolImageFlatBoxAAMix() throws Exception {
createPerfMeter(testName).exec(createPR(volImgFlatBoxMixedRenderer).configure(AA));
}
public void testVolImageWiredQuadBat() throws Exception {
createPerfMeter(testName).exec(createPR(volImgWiredQuadBatchedRenderer));
}
public void testVolImageWiredQuadMix() throws Exception {
createPerfMeter(testName).exec(createPR(volImgWiredQuadMixedRenderer));
}
public void testVolImageWiredQuadAABat() throws Exception {
createPerfMeter(testName).exec(createPR(volImgWiredQuadBatchedRenderer).configure(AA));
}
public void testVolImageWiredQuadAAMix() throws Exception {
createPerfMeter(testName).exec(createPR(volImgWiredQuadMixedRenderer).configure(AA));
}
public void testVolImageTextNoAABat() throws Exception {
createPerfMeter(testName).exec(createPR(volImgTextBatchedRenderer));
}
public void testVolImageTextNoAAMix() throws Exception {
createPerfMeter(testName).exec(createPR(volImgTextMixedRenderer));
}
private static void help() {
System.out.print("##############################################################\n");
System.out.printf("# %s\n", VERSION);
System.out.print("##############################################################\n");
System.out.println("# java ... RenderPerfTest <args> <tests>");
System.out.println("#");
System.out.println("# Supported arguments <args>:");
System.out.println("# -h : display this help");
System.out.println("# -v : set verbose output");
System.out.println("#");
System.out.println("# -e=<mode> : set the execution mode (default: " + EXEC_MODE_DEFAULT
+ ") among " + EXEC_MODES);
System.out.println("#");
System.out.println("# -f : use FPS unit (default)");
System.out.println("# -t : use TIME(ms) unit");
System.out.println("#");
System.out.println("# -g=all|\"0-0,0-1...\" : use 'all' or specific graphics configurations");
System.out.println("#");
System.out.println("# -font=\"<name>\" : set the font name used by all text renderers");
System.out.println("# -fontSize=<number> : set the font size used by Text renderers");
System.out.println("# -fontSizeLarge=<number> : set the font size used by LargeText renderers");
System.out.println("# -text=\"<string>\" : set the text drawn by all text renderers");
System.out.println("#");
System.out.println("# -lf : list available font names");
System.out.println("# -lg : list available graphics configurations");
System.out.println("#");
System.out.println("# -n=<number> : set number of primitives (default: " + N_DEFAULT + ")");
System.out.println("# -r=<number> : set number of test repeats (default: 1)");
System.out.println("#");
System.out.println("#");
System.out.println("# -w=<number> : use number of test frames (default: 1) per screen");
System.out.println("#");
System.out.println("# -u=<number> : set number of warmup iterations (default: " + MIN_COUNT + ")");
System.out.println("#");
System.out.print("# Supported test arguments <tests>:");
final ArrayList<Method> testCases = new ArrayList<>();
for (Method m : RenderPerfTest.class.getDeclaredMethods()) {
if (m.getName().startsWith("test") && !ignoredTests.contains(m.getName())) {
testCases.add(m);
}
}
testCases.sort(Comparator.comparing(Method::getName));
for (Method m : testCases) {
System.out.print(extractTestName(m));
System.out.print(" ");
}
System.out.println();
}
private static String extractTestName(final Method m) {
return m.getName().substring("test".length());
}
public static void main(String[] args)
throws NoSuchMethodException, NumberFormatException {
// Set the default locale to en-US locale (for Numerical Fields "." ",")
Locale.setDefault(Locale.US);
boolean help = false;
final ArrayList<Method> testCases = new ArrayList<>();
for (String arg : args) {
if (arg.length() >= 2) {
if (arg.startsWith("-")) {
switch (arg.substring(1, 2)) {
case "e":
if (arg.length() >= 3) {
EXEC_MODE = arg.substring(3).toLowerCase();
}
break;
case "f":
if (arg.length() == 2) {
USE_FPS = true;
} else {
if ((arg.length() > 6) && "font=".equalsIgnoreCase(arg.substring(1, 6))) {
TEXT_FONT = arg.substring(6);
break;
}
if ((arg.length() > 10) && "fontSize=".equalsIgnoreCase(arg.substring(1, 10))) {
TEXT_SIZE_DEFAULT = Integer.parseInt(arg.substring(10));
break;
}
if ((arg.length() > 15) && "fontSizeLarge=".equalsIgnoreCase(arg.substring(1, 15))) {
TEXT_SIZE_LARGE = Integer.parseInt(arg.substring(15));
break;
}
}
break;
case "g":
if (arg.length() >= 3) {
GC_MODE = arg.substring(3).toLowerCase();
}
break;
case "h":
help = true;
break;
case "l":
if (arg.length() == 3) {
if ("f".equalsIgnoreCase(arg.substring(2, 3))) {
VERBOSE_FONT_CONFIG = true;
} else if ("g".equalsIgnoreCase(arg.substring(2, 3))) {
VERBOSE_GRAPHICS_CONFIG = true;
}
}
break;
case "t":
if (arg.length() == 2) {
USE_FPS = false;
} else {
if ((arg.length() > 6) && "text=".equalsIgnoreCase(arg.substring(1, 6))) {
TEXT_STR = arg.substring(6);
}
}
break;
case "n":
if (arg.length() >= 3) {
N = Integer.parseInt(arg.substring(3));
}
break;
case "r":
if (arg.length() >= 3) {
REPEATS = Integer.parseInt(arg.substring(3));
}
break;
case "v":
VERBOSE = true;
break;
case "w":
if (arg.length() >= 3) {
NW = Integer.parseInt(arg.substring(3));
}
break;
case "u":
if (arg.length() >= 3) {
WARMUP_COUNT = Integer.parseInt(arg.substring(3));
}
break;
default:
System.err.println("Unsupported argument '" + arg + "' !");
help = true;
}
} else {
Method m = RenderPerfTest.class.getDeclaredMethod("test" + arg);
testCases.add(m);
}
}
}
if (testCases.isEmpty()) {
for (Method m : RenderPerfTest.class.getDeclaredMethods()) {
if (m.getName().startsWith("test") && !ignoredTests.contains(m.getName())) {
testCases.add(m);
}
}
testCases.sort(Comparator.comparing(Method::getName));
}
if (help) {
help();
}
if (CALIBRATION) {
Method m = RenderPerfTest.class.getDeclaredMethod("testCalibration");
testCases.add(0, m); // first
}
if (VERBOSE) {
System.out.print("##############################################################\n");
System.out.printf("# %s\n", VERSION);
System.out.print("##############################################################\n");
System.out.printf("# Java: %s\n", System.getProperty("java.runtime.version"));
System.out.printf("# VM: %s %s (%s)\n", System.getProperty("java.vm.name"), System.getProperty("java.vm.version"), System.getProperty("java.vm.info"));
System.out.printf("# OS: %s %s (%s)\n", System.getProperty("os.name"), System.getProperty("os.version"), System.getProperty("os.arch"));
System.out.printf("# CPUs: %d (virtual)\n", Runtime.getRuntime().availableProcessors());
System.out.print("##############################################################\n");
System.out.printf("# AWT Toolkit: %s \n", TOOLKIT.getClass().getSimpleName());
System.out.printf("# Execution mode: %s\n", EXEC_MODE);
System.out.printf("# GraphicsConfiguration mode: %s\n", GC_MODE);
System.out.print("##############################################################\n");
System.out.printf("# Repeats: %d\n", REPEATS);
System.out.printf("# NW: %d\n", NW);
System.out.printf("# N: %d\n", N);
System.out.printf("# WARMUP_COUNT: %d\n", WARMUP_COUNT);
System.out.printf("# Unit: %s\n", USE_FPS ? "FPS" : "TIME(ms)");
System.out.print("##############################################################\n");
System.out.printf("# Font: '%s'\n", TEXT_FONT);
System.out.printf("# Text: '%s'\n", TEXT_STR);
System.out.printf("# FontSize: %s\n", TEXT_SIZE_DEFAULT);
System.out.printf("# FontSizeLarge: %s\n", TEXT_SIZE_LARGE);
System.out.print("##############################################################\n");
}
// Graphics Configuration handling:
final Set<String> fontNames = new LinkedHashSet<>();
final Map<String, GraphicsConfiguration> gcByID = new LinkedHashMap<>();
final Map<GraphicsConfiguration, String> idByGC = new HashMap<>();
final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
for (String name : ge.getAvailableFontFamilyNames()) {
fontNames.add(name);
}
// Check font:
if (!fontNames.contains(TEXT_FONT)) {
System.err.println("Bad font name: [" + TEXT_FONT + "] !");
VERBOSE_FONT_CONFIG = true;
}
if (VERBOSE_FONT_CONFIG) {
System.out.print("# Available font names: ");
for (String name : fontNames) {
System.out.print("'");
System.out.print(name);
System.out.print("' ");
}
System.out.println();
}
final GraphicsDevice[] gds = ge.getScreenDevices();
if (VERBOSE_GRAPHICS_CONFIG) {
System.out.println("# Available GraphicsDevice(s) and their GraphicsConfiguration(s):");
}
for (int gdIdx = 0; gdIdx < gds.length; gdIdx++) {
final GraphicsDevice gd = gds[gdIdx];
if (VERBOSE_GRAPHICS_CONFIG) {
System.out.println("# [" + gdIdx + "] = GraphicsDevice[" + gd.getIDstring() + "]");
}
final GraphicsConfiguration[] gcs = gd.getConfigurations();
for (int gcIdx = 0; gcIdx < gcs.length; gcIdx++) {
final GraphicsConfiguration gc = gcs[gcIdx];
final String gcId = gdIdx + "-" + gcIdx;
gcByID.put(gcId, gc);
idByGC.put(gc, gcId);
if (VERBOSE_GRAPHICS_CONFIG) {
System.out.println("# - [" + gcId + "] = GraphicsConfiguration[" + gc + "] bounds:" + gc.getBounds());
}
}
}
final Set<GraphicsConfiguration> gcSet = new LinkedHashSet<>();
if (GC_MODE != null) {
if (!GC_MODE_DEF.equals(GC_MODE)) {
if (GC_MODE_ALL.equals(GC_MODE)) {
gcSet.addAll(gcByID.values());
} else {
for (String gcKey : GC_MODE.split(",")) {
final GraphicsConfiguration gc = gcByID.get(gcKey);
if (gc != null) {
gcSet.add(gc);
} else {
System.err.println("Bad GraphicsConfiguration identifier 'x-y' where x is GraphicsDevice ID " +
"and y GraphicsConfiguration ID : [" + gcKey + "] ! (available values: " + gcByID.keySet() + ")");
}
}
}
}
}
if (gcSet.isEmpty()) {
final GraphicsDevice gdDef = ge.getDefaultScreenDevice();
final GraphicsConfiguration gcDef = gdDef.getDefaultConfiguration();
final String gcId = idByGC.get(gcDef);
if (VERBOSE_GRAPHICS_CONFIG) {
System.out.println("# Using default [" + gcId + "] = GraphicsConfiguration[" + gcDef + "] bounds:" + gcDef.getBounds());
}
gcSet.add(gcDef);
}
final List<GraphicsConfiguration> gcList = new ArrayList<>(gcSet);
final int NGC = gcList.size();
System.out.print("# Using GraphicsConfiguration(s): ");
for (GraphicsConfiguration gc : gcList) {
final String gcId = idByGC.get(gc);
System.out.print("[" + gcId + "][" + gc + "]");
System.out.print(" ");
}
System.out.println();
final List<RenderPerfTest> instances = new ArrayList<>();
int retCode = 0;
try {
if (!help) {
final List<Thread> threads = new ArrayList<>();
for (int i = 0; i < NGC; i++) {
final GraphicsConfiguration gc = gcList.get(i);
for (int j = 0; j < NW; j++) {
final RenderPerfTest rp = new RenderPerfTest(gc);
instances.add(rp);
threads.add(rp.createThreadTests(threads.size() + 1, j + 1, testCases));
}
}
if (TRACE_SYNC) traceSync("testCount: " + testCount);
initThreads(threads.size());
initBarrierStart();
for (Thread thread : threads) {
if (TRACE_SYNC) traceSync(thread.getName() + " starting...");
thread.start();
}
for (int n = 0; n < testCount; n++) {
if (VERBOSE) {
final int k = n / REPEATS;
final String methodName = extractTestName(testCases.get(k));
System.out.println("# --- Test [" + (n + 1) + " / " + testCount + "] = " + methodName + " ---");
}
// reset stop barrier (to be ready):
initBarrierStop();
if (TRACE_SYNC) traceSync("Waiting " + threadCount + " threads to be ready...");
readyCount.await();
if (TRACE_SYNC) traceSync("Threads are ready => starting benchmark on " + threadCount + " threads now");
triggerStart.countDown();
// reset done barrier (to be ready):
initBarrierDone();
if (TRACE_SYNC) traceSync("Waiting " + threadCount + " threads to complete benchmark...");
completedCount.await();
if (TRACE_SYNC) traceSync("Test completed on " + threadCount + " threads => stopping benchmark on all threads now");
triggerStop.countDown();
// reset start barrier (to be ready):
initBarrierStart();
if (TRACE_SYNC) traceSync("Waiting " + threadCount + " threads to exit test...");
doneCount.await();
if (TRACE_SYNC) traceSync("Test exited on " + threadCount + " threads => finalize benchmark on all threads now");
triggerExit.countDown();
}
for (Thread thread : threads) {
thread.join();
if (TRACE_SYNC) traceSync(thread.getName() + " terminated");
}
}
} catch (Throwable th) {
System.err.println("Exception occurred during :");
th.printStackTrace(System.err);
retCode = 1;
} finally {
for (RenderPerfTest rp : instances) {
try {
rp.fh.hideFrameAndWait();
} catch (Throwable th) {
System.err.println("Exception occurred in hideFrameAndWait():");
th.printStackTrace(System.err);
retCode = 1;
}
}
// ensure jvm immediate shutdown:
System.exit(retCode);
}
}
// thread synchronization
private static int threadCount = 0;
private static int testCount = 0;
private static volatile String testName = null;
private static volatile CountDownLatch readyCount = null;
private static volatile CountDownLatch triggerStart = null;
private static volatile CountDownLatch completedCount = null;
private static volatile CountDownLatch triggerStop = null;
private static volatile CountDownLatch doneCount = null;
private static volatile CountDownLatch triggerExit = null;
static void traceSync(final String msg) {
System.out.println("[" + System.nanoTime() + "] " + msg);
}
private static void initThreads(int count) {
threadCount = count;
if (TRACE_SYNC) traceSync("initThreads(): threadCount: " + threadCount);
}
static boolean isMultiThreads() {
return threadCount > 1;
}
private static void initBarrierStart() {
readyCount = new CountDownLatch(threadCount);
triggerStart = new CountDownLatch(1);
}
private static void initBarrierStop() {
completedCount = new CountDownLatch(threadCount);
triggerStop = new CountDownLatch(1);
}
private static void initBarrierDone() {
doneCount = new CountDownLatch(threadCount);
triggerExit = new CountDownLatch(1);
}
public Thread createThreadTests(final int threadId, final int frameId,
final ArrayList<Method> testCases) throws Exception {
fh.setIds(threadId, frameId);
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
fh.prepareFrameEDT(VERSION + " [" + fh.threadId + "]");
final JLabel label = new JLabel((DELAY_START) ? "Waiting 3s before starting benchmark..." : "Starting benchmark...");
label.setForeground(Color.WHITE);
final JPanel panel = new JPanel();
panel.add(label);
fh.showFrameEDT(panel);
}
});
// Wait frame to be shown:
fh.waitFrameShown();
// Set test count per thread:
testCount = testCases.size() * REPEATS;
final RenderPerfTest rp = this;
return new Thread("RenderPerfThread[" + threadId + "]") {
@Override
public void run() {
if (DELAY_START) {
RenderPerfTest.sleep(3000);
}
try {
for (Method m : testCases) {
for (int i = 0; i < REPEATS; i++) {
testName = extractTestName(m);
m.invoke(rp);
}
}
} catch (Throwable th) {
System.err.println("Exception occurred in RenderPerfThread[" + threadId + "]:");
th.printStackTrace(System.err);
}
}
};
}
private static void sleep(final long millis) {
if (millis > 0) {
try {
Thread.sleep(millis);
} catch (InterruptedException ie) {
ie.printStackTrace(System.err);
}
}
}
/** regular expression used to match characters different than alpha/numeric/_/-/. (1..n) */
private final static Pattern PATTERN_NON_FILE_NAME = Pattern.compile("[^a-zA-Z0-9\\-_\\.]");
private static String replaceNonFileNameChars(final String value) {
return PATTERN_NON_FILE_NAME.matcher(value).replaceAll("_");
}
}