Tutoriel de mesure des performances de la bibliothèque JFreeChart sous SWT pour un affichage temps réel

package com.developpez.realtimecharting.jfreechart;

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

public class JFreeChartRTCTest {

    /**
     * The application shell
     */
    private static Shell shell;

    /**
     * The entry point method for the test.
     * @param args : not used
     */
    public static void main(String[] args) {
        /* 
         * Create display and shell. 
         * Assign application name, shell title and size.
         */
        Display.setAppName("JFreeChart RTC SWT");
        Display display = new Display();
        shell = new Shell(display);
        shell.setText("JFreeChart Real Time Charting with SWT");
        shell.setMaximized(true);
        
        /* Open the shell maximized */
        shell.open();
        
        /* SWT display loop */
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) display.sleep();
        }
        display.dispose();
        
    }

}

package com.developpez.realtimecharting.jfreechart;

import java.awt.Color;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.XYPlot;
import org.jfree.data.Range;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.experimental.chart.swt.ChartComposite;
            
public class JFreeChartRTCTest {

    /**
     * The number of charts that will be displayed
     */
    private static int nbCharts = 1;
    
    /**
     * The number of series per chart
     */
    private static int nbSeriesPerChart = 1;

    /**
     * An array of chart composite containing each JFree chart
     */
    private static ChartComposite[] charts;
    
    /**
     * The application shell
     */
    private static Shell shell;

    /**
     * This method create JFree chart XYSeries
     * @param nbSeries number of series to be created in the chart
     * @param chartComposite SWT chart composite containing the chart
     */
    private static void createSeries(int nbSeries, ChartComposite chartComposite) {
        //Create XY Collection as usual with JFree chart
        XYSeriesCollection xySeriesCollection = new XYSeriesCollection();
        //Loop on series number
        for (int i = 0; i < nbSeries; i++) {
            //Create series
            XYSeries xySeries = new XYSeries("Serie" + (i+1), false, false);
            //Add created series to the collection of chart XY Series collection
            xySeriesCollection.addSeries(xySeries);
        }
        //Assign XY Series collection to chart data set
        ((XYPlot)chartComposite.getChart().getPlot()).setDataset(xySeriesCollection);
    }
    
    /**
     * This method creates charts area. A grid layout is assigned to the shell.
     * If more than one chart will be displayed, grid layout will contain two columns.
     * In each cell of the grid, a JFree chart XY Line is created and wrapped into a
     * ChartComposite in order to be displayed with SWT. Finally, we create series
     * in the current JFree chart.
     */
    private static void createChartsArea() {
        shell.setLayout(new GridLayout((nbCharts>1?2:1), true));
        charts = new ChartComposite[nbCharts];
        //Loop on charts
        for (int i = 0; i < charts.length; i++) {
            //Create XY line chart
            JFreeChart jFreeChart = ChartFactory.createXYLineChart(null, null, null, null);
            //Some appearance
            jFreeChart.setBackgroundPaint(Color.BLACK);
            jFreeChart.getLegend().setBackgroundPaint(Color.BLACK);
            jFreeChart.getLegend().setItemPaint(Color.WHITE);
            ((XYPlot)jFreeChart.getPlot()).setBackgroundPaint(Color.BLACK);
            ((XYPlot)jFreeChart.getPlot()).getDomainAxis().setAutoRange(false);
            ((XYPlot)jFreeChart.getPlot()).getDomainAxis().setRange(new Range(0, 10));
            ((XYPlot)jFreeChart.getPlot()).getDomainAxis().setTickLabelPaint(Color.WHITE);
            ((XYPlot)jFreeChart.getPlot()).getRangeAxis().setTickLabelPaint(Color.WHITE);
            ((XYPlot)jFreeChart.getPlot()).setDomainGridlinesVisible(false);
            ((XYPlot)jFreeChart.getPlot()).setRangeGridlinesVisible(false);
            jFreeChart.setAntiAlias(false);
            //Wrap JFree chart in a Chart composite
            charts[i] = new ChartComposite(shell, SWT.NONE, jFreeChart, false);
            charts[i].setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
            //Create series in this chart
            createSeries(nbSeriesPerChart, charts[i]);
        }
    }
    
    /**
     * The entry point method for the test.
     * @param args : not used
     */
    public static void main(String[] args) {
        /* 
         * Create display and shell. 
         * Assign application name, shell title, size and layout.
         */
        Display.setAppName("JFreeChart RTC SWT");
        Display display = new Display ();
        shell = new Shell (display);
        shell.setText("JFreeChart Real Time Charting with SWT");
        shell.setMaximized(true);
        
        /* Create charts area */
        createChartsArea();
        
        /* Open the shell to display charts */
        shell.open ();
        
        /* SWT display loop */
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) display.sleep();
        }
        display.dispose();
        
    }

}

/**
 * This class generates data for each series of all charts.
 * It simulates 1000Hz sin data acquisition. Generation is called every
 * 100ms, producing 100 samples.
 */
private static class GenerateData extends TimerTask {
    
    /**
     * Samples number
     */
    private final int nbSamples = 100;
    
    /**
     * Time (domain in JFreeChart) values
     */
    private final Double[] time = new Double[nbSamples];
    
    /**
     * Amplitude (range in JFreeChart) values
     */
    private final Double[] y = new Double[nbSamples];
    
    /**
     * Initial time values. Used when new samples are received.
     */
    private double initialTime = -1/1000.0;
    
    /**
     * This is the main method of the timer task. It generates 100 samples
     * for each series that will be displayed in charts at a rate of 100ms.
     * When this rate is not supported, each events will be delayed, as
     * specified in Timer class documentation (<a href=
     * "https://docs.oracle.com/javase/6/docs/api/java/util/Timer.html#schedule(java.util.TimerTask,%20long,%20long)"
     * >see here</a>). These Delays will be visible on screen (display will jerk).
     */
    @Override
    public void run() {
        //Loop on charts
        for (int numChart = 0; numChart < charts.length; numChart++) {
            
            final ChartComposite chart = charts[numChart];
            
            //Build time array
            for (int i = 0; i < time.length; i++) time[i] = initialTime + i/1000.0;
            
            //Updates must be done in SWT UI thread
            shell.getDisplay().syncExec(new Runnable() {
                @Override
                public void run() {
                    //Loop on series
                    final XYSeriesCollection xySeriesCollection = (XYSeriesCollection) ((XYPlot)chart.getChart().getPlot()).getDataset();
                    for (int j = 0; j < xySeriesCollection.getSeriesCount(); j++) {
                        final XYSeries serie = xySeriesCollection.getSeries(j);
                        //Get series number in chart : it will be used as sin's frequency
                        int frequency = Integer.parseInt(serie.getKey().toString().substring(serie.getKey().toString().length()-1)); 
                        //Generate sin's samples
                        for (int i = 0; i < y.length; i++) {
                            y[i] = 5*Math.sin(2*Math.PI*(frequency/10.0)*time[i]);
                            //Add sample to corresponding series, Update only when all samples have been added
                            serie.add(time[i], y[i], ((i == y.length - 1)?true:false));
                        }
                    }
                }
            });

        }
        //Update initialTime for next series samples 
        initialTime = time[time.length - 1] + 1/1000.0;
        
        //Stop when 10s have been acquired
        if(initialTime > 10) {
            cancel();
            shell.getDisplay().asyncExec(new Runnable() {
                @Override
                public void run() {
                    shell.close();
                }
            });
        }
    }
    
}

public static void main(String[] args) {
    /* 
     * Create display and shell. 
     * Assign application name, shell title, size and layout.
     */
    Display.setAppName("JFreeChart SWT");
    Display display = new Display ();
    shell = new Shell (display);
    shell.setText("Real Time JFreeChart SWT");
    shell.setMaximized(true);
    
    /* Create charts area */
    createChartsArea();
    
    /* Open the shell to display charts */
    shell.open();
    
    /* Launch Data timer generation : generates data each 100ms */ 
    Timer timer = new Timer();
    GenerateData generateData = new GenerateData();
    timer.schedule(generateData, 1000, 100);
    
    /* SWT display loop */
    while (!shell.isDisposed()) {
        if (!display.readAndDispatch()) display.sleep();
    }
    display.dispose();
    
    /* Stop data timer */
    timer.cancel();

}

private ArrayList<Long> drawTimes = new ArrayList<Long>(0);

/**
* Return draw times : elapsed times between start and end of chart drawing 
* 
* @return an array of double containing elapsed times, in ms
*/
public double[] getDrawTimes() {
    double[] values = new double[drawTimes.size()];
      for (int i = 0; i < values.length; i++) {
        values[i] = drawTimes.get(i);
    }
    return values;
}    

/**
...
*/
@Override public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor,
            PlotState parentState, PlotRenderingInfo info) {

long time = System.nanoTime();
...
...
drawTimes.add(System.nanoTime() - time);

}

...
//Stop when 10s have been acquired
if(initialTime > 10) {
    cancel();
    
    //Retrieve all draw times of each chart, saving them in an HashMap
    HashMap<Integer, double[]> drawTimesMap = new HashMap<Integer, double[]>(); 
    for (int numChart = 0; numChart < charts.length; numChart++) {
        final ChartComposite chart = charts[numChart];
        double[] drawTimes = chart.getChart().getXYPlot().getDrawTimes();
        drawTimesMap.put(numChart, drawTimes);
    }
    
    //Compute some statistics on these values
    Statistics.compute(drawTimesMap, nbCharts, nbSeriesPerChart, "JF");
    
    //Close application
    shell.getDisplay().asyncExec(new Runnable() {
        @Override
        public void run() {
            shell.close();
        }
    });
}
...

package com.developpez.realtimecharting;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.HashMap;

import org.apache.commons.math3.stat.StatUtils;

/**
 * Compute statistics like mean, variance and quartiles
 */
public final class Statistics {
    
    /**
     * 
     * @param drawTimesMap : hashMap containing all the display elasped times
     * @param nbCharts : the number of charts in the shell
     * @param nbSeriesPerChart : the number of series per chart
     * @param library : the library for which we compute these statistics ("JF" : JFreeChart)
     */
    public static void compute(HashMap<Integer, double[]> drawTimesMap, int nbCharts, int nbSeriesPerChart, String library) {
        //Assume there are always the same number of drawing events for each chart
        int nbDrawEvents = ((double[])drawTimesMap.get(0)).length;
        
        //An array which will contains these values, 
        //summed when there are more than one chart
        double[] totalValues = new double[nbDrawEvents];
        for (double[] values : drawTimesMap.values()) {
           for (int i = 0; i < values.length; i++) {
               totalValues[i] = totalValues[i]  + values[i];
           }
        }

        //Compute statistics 
        double mean = StatUtils.mean(totalValues);
        double stdDev = Math.sqrt(StatUtils.variance(totalValues));
        double min = StatUtils.min(totalValues);
        double max = StatUtils.max(totalValues);
        double quartile1 = StatUtils.percentile(totalValues, 25);
        double median = StatUtils.percentile(totalValues, 50);
        double quartile3 = StatUtils.percentile(totalValues, 75);
        String condition = "C" + nbCharts + "S" + nbSeriesPerChart + library;
        
        //Display results in console
        System.out.printf("Condition : %s\n", condition);
        System.out.printf("nbDrawEvents : %d\n", nbDrawEvents);
        System.out.printf("min : %f ms\n", + min);
        System.out.printf("quartile1 : %f ms\n", quartile1);
        System.out.printf("mean : %f ms\n", mean);
        System.out.printf("median : %f ms\n", median);
        System.out.printf("quartile3 : %f ms\n", quartile3);
        System.out.printf("max : %f ms\n", max);
        System.out.printf("stdDev : %f ms", stdDev);
        
    }

}

/*
 *  Arguments (if not null) : nb chart, nb series per chart, 
 * file name and create or append to results file 
 */
public static void main(String[] args) {
    
    /* Arguments (if not null) : nb chart, nb series per chart, 
    file name and create or append to results file */
    if(args != null && args.length == 4) {
        nbCharts = Integer.parseInt(args[0]);
        nbSeriesPerChart = Integer.parseInt(args[1]);
        resultFileName = args[2];
        createResultFile = Boolean.parseBoolean(args[3]);
    }
...

...
/**
 * 
 * @param drawTimesMap : hashMap containing all the display elasped times
 * @param nbCharts : the number of charts in the shell
 * @param nbSeriesPerChart : the nomber of series per chart
 * @param resultFileName : the results file's name, or null 
 * @param createResultFile : create or append to results file's name. No used if resultFileName is null
 * @param library : the library for which we compute these statistics ("JF" : JFreeChart)
 */
public static void compute(HashMap<Integer, double[]> drawTimesMap, int nbCharts, int nbSeriesPerChart, String resultFileName, boolean createResultFile, String library) {
    //Assume there are always the same number of drawing events for each chart
    int nbDrawEvents = ((double[])drawTimesMap.get(0)).length;

...

    System.out.printf("max : %f ms\n", max);
    System.out.printf("stdDev : %f ms", stdDev);
    
    /* Create or append to result file if necessary */
    if(resultFileName != null) {
        try {
            //We only need two decimals
            NumberFormat formatter = new DecimalFormat("#0.00"); 
            File resultFile = new File(resultFileName);
            //If results file must be created, delete it if it exists
            if(createResultFile && resultFile.exists()) resultFile.delete();
            //Create PrintWriter for results file
            PrintWriter printWriter = new PrintWriter(new FileOutputStream(resultFile, !createResultFile));
            //If results file must be created, print header
            if(createResultFile) printWriter.println("Condition\tnbDrawEvents\tmin(ms)\tQ1(ms)\tmean(ms)\tmedian(ms)\tQ3(ms)\tmax(ms)\tstdDev(ms)");
            //Print results
            printWriter.printf("%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", condition, nbDrawEvents , formatter.format(min), formatter.format(quartile1), 
                                              formatter.format(median), formatter.format(quartile3), formatter.format(max), 
                                              formatter.format(mean), formatter.format(stdDev));
            //Close file
            printWriter.flush();
            printWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
...

package com.developpez.realtimecharting;

import com.developpez.realtimecharting.jfreechart.JFreeChartRTCTest;

/**
 * 
 * @author frank buloup
 *
 */
public class AllTests {
    
    public static void main(String[] args) {
        
        try {
            
            String resultsFile = "results.txt";
            
            //Condition C1S1
            JFreeChartRTCTest.main(new String[]{"1", "1", resultsFile, "true"});
            Thread.sleep(100);
            //Condition C1S2
            JFreeChartRTCTest.main(new String[]{"1", "2", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C1S3
            JFreeChartRTCTest.main(new String[]{"1", "3", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C1S4
            JFreeChartRTCTest.main(new String[]{"1", "4", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C2S1
            JFreeChartRTCTest.main(new String[]{"2", "1", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C2S2
            JFreeChartRTCTest.main(new String[]{"2", "2", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C2S3
            JFreeChartRTCTest.main(new String[]{"2", "3", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C2S4
            JFreeChartRTCTest.main(new String[]{"2", "4", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C4S1
            JFreeChartRTCTest.main(new String[]{"4", "1", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C4S2
            JFreeChartRTCTest.main(new String[]{"4", "2", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C4S3
            JFreeChartRTCTest.main(new String[]{"4", "3", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C4S4
            JFreeChartRTCTest.main(new String[]{"4", "4", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C6S1
            JFreeChartRTCTest.main(new String[]{"6", "1", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C6S2
            JFreeChartRTCTest.main(new String[]{"6", "2", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C6S3
            JFreeChartRTCTest.main(new String[]{"6", "3", resultsFile, "false"});
            Thread.sleep(100);
            //Condition C6S4
            JFreeChartRTCTest.main(new String[]{"6", "4", resultsFile, "false"});
            Thread.sleep(100);
            
            System.exit(0);
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

}