Stop the press!
Dramatic test results counter recent claims made by Visiblox and reveal that according to their own test suite and definition, SciChart is currently the worlds fastest WPF and Silverlight Chart. The conclusion is clear, SciChart v1.2.1.678 line rendering outperforms Visiblox Ultimate 2.3.1 by 30%-250% after a slight modification of their test suite. Please read more to see the full article. We invite third parties to peer review the results and publish what they find.

Recently we reported that Scott Logic, the makers of Visiblox Charts had published an article entitled WPF Charting Performance Comparison (The battle continues).

Visiblox had made a performance comparison of line rendering between their own Visiblox Ultimate edition and SciChart - High Performance WPF Silverlight Charts, culminating in the claim that Visiblox had produced the "Worlds fastest WPF and Silverlight charts". We think this is a great article and presents that a new class of WPF/Silverlight Charting component using hybrid vector/raster graphics (pioneered by SciChart) is leading the pack, however we also believe the test to be a little narrow, test setup flawed and hence conclusion a litte hasty.

We've been in touch with Colin from Visiblox who has kindly provided us with a copy of the test suite. We have peer reviewed the test suite and noticed there are a few discrepancies between the tests for SciChart and for Visiblox. We don't believe that these were intentional and don't wish to jump to conclusions. It is more likely a result of the Visiblox Team not understanding how to get the best from the SciChart API.

We invite any third parties to download and run the test suite (includes SciChart binaries, requires Visiblox Ultimate trial binaries), peer review and verify our results/publish their own results.

The Test Setup


We noticed the following three issues in the Test Suite provided to us by Visiblox. These were:

  • SciChart uses Antialiasing by default. Visiblox Ultimate does not have this feature, so we turned SciCharts Antialiasing off by setting FastLineRenderableSeries.AntiAliasing=False.

    Rendering smooth lines with Antialiasing uses a considerable amount of CPU so setting this switch evens the playing field somewhat.
  • SciChart Draws major and minor grid lines and ticks by default. The Visiblox test had Minor grid lines switched off, so we turned SciChart's minor grid lines off to match by setting NumericAxis.DrawMinorGridLines=False and NumericAxis.DrawMinorTicks=False.

    SciChart uses Hybrid Vector/Raster graphics and grid lines are drawn on a Canvas using WPF Shape primitives. In our performance tests we have noticed that 30% of the render time is spent clearing and refilling the grid lines canvas, so by drawing fewer primitives (turning Minor Grid Lines off) will have a positive effect on performance.

  • SciChart does not support removal of datapoints from its standard DataSeries. To perform a scrolling action the original test suite provided by Visiblox was working around this by clearing the dataseries and re-filling entire the series on each single point added using two LINQ queries on a separate Points array.

    From a performance perspective this is quite significant as the test harness for SciChart was maintaining two arrays - a List<Point> which was being appended to and a SciChart DataSeries which was being cleared/refilled on each point append. See the code below to see what we mean.

    Instead, the test should have used a FifoSeries from the SciChart API. This would results in the same visual effect - a scrolling chart with old points discarded, however internally this is a far more efficient implementation, pooling memory and ensuring the least amount of garbage collection. See our FIFO Series demo which shows what these series types can do

Here is a summary of the code we have changed from the original test suite provided by Colin. Please see SciChartLineSeries.xaml, SciChartLineSeries.xaml.cs in the attached test suite.

Visiblox Code (Included for comparison)


// Add Point method, called tens of thousands of times during the tests
public void AddPoint(Point point)
{
    // Achieve a scrolling effect by removing first point and appending
	if (_dataSeries.Count >= _maxDataPoints)
        _dataSeries.RemoveAt(0);
    _dataSeries.Add(new DataPoint<double,double>(point.X, point.Y));
}

SciChart Test Code (Original version provided by Visiblox)


// Add Point method, called tens of thousands of times during the tests
public void AddPoint(Point point)
{
      // Achieve a scrolling effect by removing first point and appending
	  // on a separate generic points list, then clearing the
	  // SciChart dataseries and refilling via LINQ on each point append
      points.Add(point);
 
      // Clear first point if threshold is met
      if (points.Count >= _maxDataPoints)
            points.RemoveAt(0);
 
      // One each point added, clear the dataseries and 
      // recreate using two LINQ queries from separate Points array
      _dataSeries.Clear();
      _dataSeries.Append(points.Select(p => p.X), points.Select(p => p.Y));
}

SciChart Test Code (Post modification by our engineers)


// Ctor of the test case, called once per test case
public SciChartLineSeries(int maxDataPoints)
{
      // Using a FifoSeries with N data-points yields the same operation as Visiblox's RemoveAt(0)
      _dataSeries = dataSeriesSet.AddFifoSeries(maxDataPoints);
}

// ...

// Add Point method, called tens of thousands of times
public void AddPoint(Point point)
{
      // _dataSeries is declared as a Fifo series with count= _maxDataPoints.
      //  This automatically discards points after _maxDataPoints is reached
      _dataSeries.Append(point.X, point.Y);
}

Visually our modifications to the tests yield the same effect - both charts (Visiblox and SciChart) are rendering Major Grid Lines but not minors, both are the same size and visible range, both with the same point counts and both achieve a scrolling effect: old points are discarded on the left as new points are added on the right.

The performance results of these modifications are quite dramatic! We have posted an Excel spreadsheet which you may download to review. Some inline images follow:





It should be noted all the above tests are performed with resampling off and using the current version of Visiblox Ultimate (v2.3.1), plus the same SciChart version that was used in the original test (v.1.2.678). Visiblox believed turning resampling off created a fairer test as showcases the raw rendering performance of each component without any optimizations.

This is true in part, however in real-world usage most users will wish to have the highest possible performance in a charting control with the best visual acuity. It should be noted that with SciChart's proprietary Nyquist resampling algorithm enabled (on by default) SciChart is capable of rendering many millions of datapoints, which is far beyond the maximum theoretical limit of 200,000+ points quoted by Visiblox. In addition, Nyquist resampling results in a reduced dataset being rendered which is the minimum required to accurately recreate the original data without aliasing. In laymens terms, there is no loss of information visually when using Nyquist resampling. this can be verified by viewing our performance demo, which showcases the various resampling methods. Nyquist is known as "MinMax". Try switching between MinMax and None once the above demo has reached 1,000,000 data-points and seeing the difference.





So, we are cautious to make the next statement, however, under the same test conditions as provided to us by Visiblox, but with a minor modification, SciChart is revealed to be the worlds fastest WPF and Silverlight Chart component and never lost the crown. Of course, we believe that in order to seriously make such a statement it would be wise to allow third parties to peer review the test suite and publish the results they find. Also, this is just one test case. We have some ideas for other test cases which must be evaluated before either side can really lay hold of this claim. For instance, further test cases should include:

  • Testing multiple series rendering. The test should draw 5, 10, 20, 50, 100, 1000 series of 1000 points on the screen on a single chart component and measure startup time (time to first draw) and refresh rate (when appending points).
  • Testing additional series types. SciChart supports Candlestick, Mountain, Line (tested above), Column, Scatter (tested above) and soon OHLC, Digital (Step) line. Each of these series types should be included in the test.
  • Testing multiple chart panes. What happens when you include 9 chart panes, each of several series and thousands of points and re-run the test?
  • Testing large dataset support using resampling. What happens when you take the most visually accurate sampling methods in both chart components (SciChart's is Nyquist, known as ResamplingMode.MinMax in the API) and draw 100k, 1M, 2M, 5M points? What is the refresh rate? What is the startup time? In SciChart this test can be repeated for all series types (OHLC, Candlestick, Line, Mountain, Column, Digital Line, Scatter).

 

The above would make a decent test suite which may be able to prove whether SciChart is the worlds fastest WPF and Silverlight Chart or whether Visiblox rightfully has this claim. Of course, results must be peer reviewed and test suites evaluated by third parties. In any case the world of WPF and Silverlight charting has changed for good and these once slow and combersome platforms are now opening up a whole world of possibilities for scientific and financial visualization.

Finally, get in touch with us to tell us what you think of SciChart, we'd love to hear your feedback!