RSS Feed
News
Mar
16
iOS Chart Performance: Metal vs. OpenGL Speed comparison
Posted by Andrew on 16 March 2019 09:00 AM


It’s been almost three years since we released SciChart iOS: Realtime Charts for the iOS Platform. Right from the start, our goal has been to create the worlds fastest iOS Charts, but also produce visually appealing, productive, easy to use and flexible / powerful iOS charting controls, capable of being used in demanding business apps.

Our first version of SciChart iOS beat the speed records of any previous known iOS Chart control and we have only worked to improve our chart performance since then. We realise though, that speed isn’t everything, and also have been focussing on flexibility so that we can provide a compelling offering vs. open source iOS Chart components.

However, if it’s iOS Chart Performance you are looking for, then you have come to the right place! With the recent release of SciChart iOS v2.5 with metal support, we have taken the opportunity to update present new performance results of our iOS Chart control: SciChart iOS, vs. a number of competing open source iOS charts and commercial charts, as well as demonstrate the performance differences in our iOS Charts between Metal & OpenGL rendering on a variety of devices.

Topics in this article include:

Test Setup

iOS Chart Frameworks Compared in this Article

In this article we compare the performance of the following chart controls:

  • Core-plot; an Open source iOS Chart based on Core-graphics
  • Charts; an Open Source iOS Chart based on Core-graphics
  • Shinobi: a commercial iOS Chart library made by Scott Logic Ltd which uses OpenGL
  • SciChart (with our OpenGL renderer plugin)
  • SciChart (with our new Metal renderer plugin)

Tests Carried out

A number of tests are carried out to really stress the chart controls, these are:

Test 1: Hundreds of Series Line Chart Test

iOS Charts Core Plot SciChart performance comparison NxM series testIn this test, tens or hundreds of series, with tens or hundreds of points are added to the chart, then the chart redraws (the same data) as fast as possible by just resizing the Y-Axis for 10 seconds per test.

Performance is measured as FPS (Frames per second) using the CADisplayLink , which fires once after each drawing pass completes.

 

Test 2: Big-Data Scatter Chart Test up to 100k points

iOS Charts Core Plot SciChart performance comparison scatter series testIn this test, thousands or hundreds of thousands of Scatter points (ellipses) are appended to a series, then the chart redraws. Immediately after, the point positions are updated in a Brownian motion fashion and the chart is drawn again.

Performance is measured as FPS (Frames per second) and recorded.

 

Test 3: Realtime Scrolling Chart Test up to 1 Million points

iOS Charts Core Plot SciChart performance comparison FIFO Streaming series testIn this test, hundreds of thousands or even up to one million points are appended to a line chart, but scrolled from right to left (as new points arrive, old are discarded). SciChart for iOS & Android has a built-in mode to handle this called Fifo data series which use a circular buffer. Other chart components you can simply remove a point for each point added.

 

 

Test 4: Realtime line drawing test up to 10k Points added per second

iOS Charts Core Plot SciChart performance comparison big-data append testPerformance is measured as FPS (Frames per second) and recorded. In this test we start off with a line chart with thousands or even tens of thousands of points. We then add hundreds or thousands of points per second to the chart, so that the series gets bigger very fast. The data is random-walk and the chart automatically zooms to fit when data is updated. This gives the appearance of a live streaming realtime chart.

Performance is measured as FPS (Frames per second) and recorded.

 

Test Hardware

For the Test Hardware, we’ve used three phones: an iPhone 5s, iPhone X, and iPhone XR. The results are interesting as they show the strengths and weaknesses of each phone when drawing realtime iOS Charts using both Metal and OpenGL.

Performance Test Results

Interpreting the Test Results

Below: All test result numbers are in FPS (Frames per second – Higher is Better), meaning, the average number of redraws per second during the test, as measured by CADisplayLink.

The Test Case Name column is understood as follows:

  • Append 1K+100 StrokeThickness = 1 means “Starting with 1,000 points on an iOS Line chart, append 100 new points in a loop with a stroke thickness of 1”
  • Append 100k + 10k Strokethickness = 3 means “Starting with 100k points on an iOS line chart, append 10k new points in a loop with a stroke thickness if 3”
  • FIFO 10k Stroke Thickness = 3 means “Load 10k points to an iOS Line Chart and scroll them to the left with a strokethickness of 3”
  • FIFO 1M Stroke Thickness = 1 means “Load 1 Million points to an iOS Line Chart and scroll them to the left with a stroke thickness of 1”
  • 100 x 100 Stroke Thickness = 3 means “Load 100 line chart series, to an iOS Chart, each with 100 points, with a stroke thickness of 3 and redraw the chart”
  • 500 x 500 Stroke Thickness = 1 means “Load 500 line chart series to an iOS Chart, each with 500 points, with a stroke thickness of 1 and redraw the chart”
  • Scatter 1000 means “Load 1,000 points to an iOS Scatter Chart and repeatedly draw the chart”
  • Scatter 100000 means “Load 100,000 points to an iOS Scatter Chart and repeatedly draw the chart”

The Results Columns (Core Plot, Charts, Shinobi, SciChart Metal, SciChart OpenGL) are understood as follows:

  • Numbers are in FPS (Frames per second), where higher is better. 30 FPS or above is smooth to the human eye.
  • Each iOS Chart has FPS reported for this test case.
  • SciChart iOS has FPS reported for both the OpenGL Renderer plugin and the new Metal Renderer plugin

Because many of the open source iOS charts we tested became unstable as dataset size increased, we skip running further tests once a chart has dropped below 5FPS. So a zero in a column means that test was skipped (the iOS Chart control was unable to render that data size).

Note that in the case where SciChart was able to run a test but other iOS Charts could not, the percentage gain was marked as INF (infinite).

The % Gain Columns are understood as follows:

  • SciChart % Gain: The Max FPS of SciChart (Metal or OpenGL) is compared to the Max FPS of open source or commercial charts and computed as a percentage.
    • e.g. 800% means SciChart was 800% faster than the fastest competing iOS Chart Control for this test case
    • whereas -5% means SciChart was 5% slower than the fastest competing iOS Chart Control for this test case.
  • Metal % Gain: The FPS of ScChart when Metal was enabled is compared to the FPS when OpenGL is enabled and computed as a percentage.
    • e.g. 99% means SciChart’s Metal renderer was 99% faster than OpenGL for this test case
    • whereas -15% means Metal was 15% slower than OpenGL for this test case.

 

Test Results iPhone X

SciChart iOS Performance Comparison vs. Open Source Charts with Metal/OpenGL on iPhoneX. SciChart iOS Performance Comparison vs. Open Source Charts with Metal/OpenGL on iPhoneX.

The iPhoneX shows strong performance results for SciChart, where our Metal rendering plugin is able to draw big data and real-time updates at smooth frame rates.

On an iPhone X, SciChart’s iOS Chart can draw:

  • A massive 100,000 scatter points at 60 FPS (nearest competitor can only draw 1,000 points at the same frame rate)
  • 200 series with 200 points on a single chart at 56 FPS (nearest competitor can only draw 50 series)
  • 100k points scrolling in the FIFO case at 58 FPS (nearest competitor
  • It can have 100k points on screen and append 1,000 new points at 54 FPS

SciChart iOS Chart Performance is 60FPS for 100k points, 200 series or 100,000 scatter points in real time on iPhone X SciChart iOS Chart Performance is 60FPS for 100k points, 200 series or 100,000 scatter points in real time on iPhone X

On an iPhone X, SciChart is considerably faster than competitors, with test cases up reporting up to 2,000% faster than the nearest competing iOS Chart component.

SciChart iOS Chart Performance gain is up to 2000% faster than competitors on an iPhone X SciChart iOS Chart Performance gain is up to 2000% faster than competitors on an iPhone X

Finally, SciChart’s Metal renderer plugin shows strong performance, with most cases comparable to SciChart’s OpenGL plugin. Some cases, a performance boost of over 100% is realised just by using the Metal renderer.

Test Results iPhone XS

SciChart iOS Performance Comparison vs. Open Source Charts with Metal/OpenGL on iPhoneXS. SciChart iOS Performance Comparison vs. Open Source Charts with Metal/OpenGL on iPhoneXS.

On the iPhone XS we have even stronger performance results. The iPhone XS is a really powerful device with a 6-core A12 Processor, vs a 6-Core A11 in the iPhone X. The iPhone XS also has a 4-core GPU vs. a 3-Core GPU in the iPhone X, and provides up to 50% faster graphics performance (source: Forbes – iPhone XS vs. iPhone X, What’s the Difference?).

This is reflected in the performance results. While some of the cases are comparable to the iPhone X, some are up to twice as fast. SciChart iOS is still able to draw hundreds of thousands of scatter points at 60 FPS, and now 500 series at 30 FPS, or a half a million points in a realtime scrolling chart at just under 30 FPS. Truly a big-data iOS Chart control. For the fastest test case SciChart iOS performs 3,800% faster than the nearest competitor.

Test Results iPhone 5s

SciChart iOS Performance Comparison vs. Open Source Charts with Metal/OpenGL on iPhone5S. SciChart iOS Performance Comparison vs. Open Source Charts with Metal/OpenGL on iPhone5S.

We’ve included the iPhone 5s as a testing device in our set of tests as well. The iPhone 5s is the oldest iOS Device which supports iOS 12 and Apple’s Metal graphics API. Because the processor is older and graphics processor less powerful, it isn’t as fast as the newer devices.

You can see a table of the Apple processor benchmarks over at browser.geekbench.com/ios-benchmarks.

The iPhone 5s has a processing power approximately 1/4 of the iPhone X and XS, so it is not a surprise that SciChart iOS is performing slower on these devices. However, it is still outperforming competing iOS Charts by a long way.

You will also note that Metal performance on the iPhone 5s is slower than OpenGL, in some cases up significantly slower. This is because the A7 processor in the iPhone 5s has less powerful GPU features than newer devices. It is therefore advisable to detect operating system and device before applying the Metal rendering plugin in SciChart iOS. You can find out how in our iOS Chart Documentation.

Conclusions

It’s hard to draw much conclusion from these test results other than SciChart’s iOS Chart Control is really, really fast!.

> SciChart iOS: Up to 3,800% faster than competing iOS Charts, able to draw millions of points in realtime

These kind of performance results may seem over the top however consider that mobile computing is really starting to grow as a platform not just to surf the web and use simple apps, but actually create real big-data utility applications for scientists, engineers, medical professionals and businessmen.

Datasets are only getting larger, and the performance demands of applications are growing. With SciChart’s iOS Charts you can add visually appealing, animated line, column, scatter, bubble charts to your iOS application, or, create new kinds of apps that enable you to visualise massive amounts of data. Never before has this second case been possible for developers of iOS Applications.

Verifying the Results

If you wish to verify the performance test results, we are happy to share a copy of our iOS Chart Performance Comparison app on request.

Why SciChart?

SciChart provides powerful, flexible, high-performance realtime iOS Charts, Android Charts and WPF Chart controls to thousands of users in 80 countries. Our customers have use SciChart to create completely novel iOS apps such as capturing and displaying large volumes of heart-rate data during physical training sessions, for realtime visualisation of cardiovascular data for medical diagnostics, visualising telemetry and more. Without SciChart’s High Performance iOS & Android charts, these kind of apps would simply not be possible.

Far from just a fast 2D line or scatter chart, our iOS, Android & Windows (WPF) Charts are powerful, flexible, fully-featured chart controls and provide a compelling alternative to open source and commercial chart libraries. You can find out more about SciChart in the articles Comparison of SciChart vs. Open Source Chart Controls, and Why SciChart, the Best WPF Charts.

For more information about how some of our customers have used SciChart iOS, please see our case studies. We have included some below, and the full set is available at www.scichart.com/case-studies-mobile. If you have any questions, or wish to get in touch to discuss what SciChart can do for you, then please contact us.

Big-Data iOS/Android Chart Case studies

Avicena Heart (iOS)

Avicena is a medical device company focused on providing critical information to patients and physicians through their mobile app. Bespoke proprietary sensors stream cardiovascular data directly to a mobile device via Bluetooth to aid in diagnosis. Avicena chose SciChart as a reliable iOS charting solution to display Realtime, High-Bandwidth Cardiovascular data in up to 90 series streamed from sensors whilst maintaining a smooth UI and allowing for bespoke customizations and annotations.

Read More

iHealth Technologies Ltd (iOS)

Ihealth needed to display 70,000 points of Realtime Cardiac data for their revolutionary health and fitness app.
Custom iOS Charts were integrated alongside their existing styling adding great features and maintaining a smooth UI.
Keen to know more? Click below and find out what SciChart did to get this project off the ground!

Read More

IMT AG (Android)

IMT AG’s custom hardware project, the Citrex H5 had a range of hardware and cost requirements. SciChart was able to work with these and get IMT’s Android powered Gas Flow Analyzer off the ground with custom features and a slick high-performance interface despite the limitations of low-cost embedded hardware.
Read on to learn more and have a look through our full case study.

Read More

The post iOS Chart Performance: Metal vs. OpenGL Speed comparison appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Nov
2
Performance debugging: Improving the speed of charts when many NaN
Posted by Andrew on 02 November 2018 12:33 PM

In this video below we have taken an example provided by a customer and shown how to improve the performance of SciChart from stuck UI to real-time when there are several series with millions of points and a high proportion of NaN gaps.

The direct video link is here.

If you have a performance issue with SciChart, and you are in support-subscription, then feel free to contact our tech-support team and we will be glad to help!

Best regards,
Andrew

The post Performance debugging: Improving the speed of charts when many NaN appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Feb
21
Performance Improvements in SciChart WPF v5.1 
Posted by Andrew on 21 February 2018 02:38 PM

SciChart WPF v5.1 will be released in the next few days. Here’s a sneak peak what we have added along with many features & bug fixe! 

Back in 2012 when SciChart WPF first came into existence, our main goal was to deliver High Performance, Realtime Charts to desktop applications on the Windows Presentation Foundation platform. Over the years our performance goalposts have moved. Originally we wanted to draw 100,000 points in realtime, then a million, then ten million! SciChart WPF v4 was an extremely fast & performant version of SciChart which was able to draw 10 million points (or more) for line series, a million or so for scatter series, and could comfortably draw hundreds or even thousands of series.

However, our users want more! Some of our power-users are using SciChart to draw huge datasets, so as a result, we’ve undertaken work to improve the speed of our WPF Charts in certain key areas, including:

Performance of Line Series when many series / few points

SciChart WPF v4 had a bottleneck where there were many series, each with few points. In this case the lossless resampling algorithm built into SciChart was unable to reduce the data drawn on screen. As a result the bottleneck because raw drawing of points.

In SciChart v5.1 we have added a new experimental drawing mode, which applies to line series only. This mode improves the performance of line series drawing up to 4x faster than previous version(s) of SciChart.

 

To enable faster drawing of line series, use the following code:

<s:SciChartSurface s3D:DirectXHelper.TryApplyDirectXRenderer="True"
                   s:PerformanceHelper.EnableExtremeDrawingManager="True">
   ... 
</s:SciChartSurface>
PerformanceHelper.SetEnableExtremeDrawingManager(sciChartSurface, true);
DirectXHelper.SetTryApplyDirectXRenderer(sciChartSurface, true);

 

Performance of FIFO / Scrolling series

SciChart WPF v4 had a bottleneck where FIFO (first in first out) DataSeries were used. In this mode, the dataseries had to be unwrapped from a circular buffer before being drawn. This copy step took some time and for larger data-sets (>10Million points) it caused a severe performance bottleneck.

In SciChart v5.1 we have added a new experimental set of resampling algorithms, which performs resampling in-place (does not unwrap). The result is the performance of FIFO Series is up to 4x faster than previous version(s) of SciChart.

To enable faster FIFO resampling, use the following code:

<s:SciChartSurface s3D:DirectXHelper.TryApplyDirectXRenderer="True"
                   s:PerformanceHelper.EnableExtremeResamplers="True">
   ... 
</s:SciChartSurface>
PerformanceHelper.SetEnableExtremeResamplers(sciChartSurface, true);
DirectXHelper.SetTryApplyDirectXRenderer(sciChartSurface, true);

 

Performance of Scatter Series with PaletteProvider (per-point colouring)

SciChart WPF v5 had a bottleneck where the Scatter Series was used with the PaletteProvider (changing point-color frequently as data updates). This was reported by several users who wanted to visualize a fourth dimension of data.

In SciChart v5.1 we have added a new series type: ExtremeScatterRenderableSeries. This series type adds an optimization which is available for DirectX only. When the optimization is enabled, points are drawn as batches and there is no performance hit when switching color dynamically in the scatter series. The new implementation is over 10x faster than the old scatter series when palette provider is enabled. (For non paletted series, the performance is the same).

 

To enable faster performance Scatter Series with PaletteProvider, use the following code:

<s:SciChartSurface s3D:DirectXHelper.TryApplyDirectXRenderer="True">
    <s:SciChartSurface.RenderableSeries>
        <s:ExtremeScatterRenderableSeries x:Name="scatterSeries">
            <s:ExtremeScatterRenderableSeries.PointMarker>
                <s:EllipsePointMarker Width="5" Height="5"/> 
            </s:ExtremeScatterRenderableSeries.PointMarker>
        </s:ExtremeScatterRenderableSeries>
    </s:SciChartSurface.RenderableSeries>
   ... 
</s:SciChartSurface>
DirectXHelper.SetTryApplyDirectXRenderer(sciChartSurface, true);
scatterSeries.PaletteProvider = new TestPaletteProvider(new Color[] { Colors.Red, Colors.Green, Colors.Blue ... } );E

// where ExtremePaletteProvider defined as 
public class TestPaletteProvider : IExtremePointMarkerPaletteProvider 
{
    private readonly List<Color> _dataPointColors;
    private readonly Values<Color> _colors = new Values<Color>();

    public TestPaletteProvider(List<Color> dataPointColors)
    {
        _dataPointColors = dataPointColors;
    }

    public Values<Color> Colors { get { return _colors; } }

    public void OnBeginSeriesDraw(IRenderableSeries rSeries)
    {
        var indexes = rSeries.CurrentRenderPassData.PointSeries.Indexes;
        var count = indexes.Count;
        _colors.Count = count;

        // copy required colors from list using data point indices
        for (int i = 0; i < count; i++)
        {
            var dataPointIndex = indexes[i];
            _colors[i] = _dataPointColors[dataPointIndex];
        }
    }
}

 

Performance and accuracy of resampling large datasets

Additional functionality has been added in SciChart v5.1. With a re-write of our resampling algorithms taking advantage of templating in C++ we now have the fastest, most accurate resampling algorithms ever, taking care of many edge cases that were reported such as handling datasets which included NaN (null points) and uneven datasets.

These improvements are enabled by setting the following code in your application:

<s:SciChartSurface s:PerformanceHelper.EnableExtremeResamplers="True">
   ... 
</s:SciChartSurface>
PerformanceHelper.SetEnableExtremeResamplers(sciChartSurface, true);

 

How Fast is SciChart’s WPF Chart?

You can see our updated performance benchmark over here at How Fast is SciChart’s WPF Chart! Over the years we have worked hard to maintain and improve performance, so that SciChart can be used in Big-Data, scientific and financial applications around the world.

Best regards,
Andrew

 

The post Performance Improvements in SciChart WPF v5.1  appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Jul
11
Case Study: Real-time Android Charts for Medical Industry
Posted by Andrew on 11 July 2016 11:00 AM

About a year and a half ago, IMT AG (Information Management Technology) approached us to ask about porting SciChart Realtime Charts on the Android operating system. At the time we only supported Windows Presentation Foundation, but thanks to their encouragement, and their sponsorship by committing to pre-order SciChart Android licenses for their team, we were able to embark on the port, and have now released SciChart’s Android Chart with record real-time performance.

mguntli

Michael Guntli from IMT AG at Droidcon Berlin

Over the past year or so, IMT have worked alongside us providing valuable feedback as we developed the worlds fastest real-time Android Chart Control, which uses a mixture of Java, C++ with the Android NDK and OpenGL ES2.0 to achieve record performance for an Android Chart. We were able to squeeze the most out of a low powered device by porting our already proven drawing and resampling algorithms from Windows to Android, and implementing them in this new chart control.

This year in June 2016, Michael Guntli from IMT AG presented at Droidcon Berlin to talk about their project. Michael’s presentation ANDROID INDUSTRIAL: REAL-TIME DATA VISUALISATION can now be viewed online and a full video can be seen below.

Antutu-Benchmark-imx6

Benchmark of the Freescale iMX6 hardware. A fraction of the speed of high-end Android devices.

Michael and his team at IMT have built a prototype device for the medical industry running on a dual-core Freescale iMX-6 hardware which uses SciChart’s Android Chart library for the real-time charting. The Freescale iMX-6 is low power ARM processor (dual core, 800MHz) that has about half the computing power of the lowest of the low cost $50 Android Smart phone, and a fraction of the speed of a high-end Nexus smartphone, yet thanks to the engineering of the IMT team and the performance of SciChart for Android, it still runs data-acquisition, processing, UI updates and of course realtime charts at a smooth 30 FPS.

The presentation content is very valuable from an engineers perspective as it goes into great detail about how to develop a truly real-time medical or industrial software with Android as an embedded operating system while running on low power ARM hardware. Some of the challenges faced by IMT are the same as our own: garbage collection, performance of the Java runtime and Android views have all required some inventive workarounds.

SciChartApp-NoProductName

View the IMT Prototype UI running SciChart Android Charts on a Freescale iMX6

Such an application demonstrates the ability of SciChart’s Android Chart component in Industrial and Medical usage where the Android operating system is used in a low-power embedded system. It also shows the amazing performance of SciChart’s Android Chart! If we can draw smooth charts on hardware that is low power, with a low CPU clock speed, then imagine what it can do on the latest smartphones or tablets!

The full presentation slides are available online, as well as a youtube video of the presentation below. There’s a little bit about SciChart at the end, and we really appreciate Michael taking the time to promote us in this way. We hope their project is a great success and we look forward to continuing to work with IMT in the future.


The post Case Study: Real-time Android Charts for Medical Industry appeared first on WPF Charts, iOS and Android Charts | SciChart.


Read more »



Jul
11
Case Study: Real-time Android Charts for Medical Industry
Posted by Andrew on 11 July 2016 11:00 AM

About a year and a half ago, IMT AG (Information Management Technology) approached us to ask about porting SciChart Realtime Charts on the Android operating system. At the time we only supported Windows Presentation Foundation, but thanks to their encouragement, and their sponsorship by committing to pre-order SciChart Android licenses for their team, we were able to embark on the port, and have now released SciChart’s Android Chart with record real-time performance.

mguntli

Michael Guntli from IMT AG at Droidcon Berlin

Over the past year or so, IMT have worked alongside us providing valuable feedback as we developed the worlds fastest real-time Android Chart Control, which uses a mixture of Java, C++ with the Android NDK and OpenGL ES2.0 to achieve record performance for an Android Chart. We were able to squeeze the most out of a low powered device by porting our already proven drawing and resampling algorithms from Windows to Android, and implementing them in this new chart control.

This year in June 2016, Michael Guntli from IMT AG presented at Droidcon Berlin to talk about their project. Michael’s presentation ANDROID INDUSTRIAL: REAL-TIME DATA VISUALISATION can now be viewed online and a full video can be seen below.

Antutu-Benchmark-imx6

Benchmark of the Freescale iMX6 hardware. A fraction of the speed of high-end Android devices.

Michael and his team at IMT have built a prototype device for the medical industry running on a dual-core Freescale iMX-6 hardware which uses SciChart’s Android Chart library for the real-time charting. The Freescale iMX-6 is low power ARM processor (dual core, 800MHz) that has about half the computing power of the lowest of the low cost $50 Android Smart phone, and a fraction of the speed of a high-end Nexus smartphone, yet thanks to the engineering of the IMT team and the performance of SciChart for Android, it still runs data-acquisition, processing, UI updates and of course realtime charts at a smooth 30 FPS.

The presentation content is very valuable from an engineers perspective as it goes into great detail about how to develop a truly real-time medical or industrial software with Android as an embedded operating system while running on low power ARM hardware. Some of the challenges faced by IMT are the same as our own: garbage collection, performance of the Java runtime and Android views have all required some inventive workarounds.

SciChartApp-NoProductName

View the IMT Prototype UI running SciChart Android Charts on a Freescale iMX6

Such an application demonstrates the ability of SciChart’s Android Chart component in Industrial and Medical usage where the Android operating system is used in a low-power embedded system. It also shows the amazing performance of SciChart’s Android Chart! If we can draw smooth charts on hardware that is low power, with a low CPU clock speed, then imagine what it can do on the latest smartphones or tablets!

The full presentation slides are available online, as well as a youtube video of the presentation below. There’s a little bit about SciChart at the end, and we really appreciate Michael taking the time to promote us in this way. We hope their project is a great success and we look forward to continuing to work with IMT in the future.


The post Case Study: Real-time Android Charts for Medical Industry appeared first on WPF Charts, iOS and Android Charts | SciChart.


Read more »



Jun
23
How Fast is SciChart’s iOS Chart?
Posted by Yaroslav Pelyukh on 23 June 2016 04:12 PM

iOS Chart Performance: TLDR

In this post, we compare the performance of three well-known iOS Charting Libraries including our own brand new & upcoming iOS Chart: SciChart for iOS. In order to conduct a fair comparison, we have developed a comparison application which generates several different chart types and measures refresh rate (FPS – Frames per Second), as well as CPU Usage and startup time on each iOS Chart library.

Our findings were:

  • “Charts” (formerly iOS-Charts, the iOS Counterpart to MPAndroidChart) had reasonable performance, but poor real-time performance and poor startup time when many series or points were present.
  • One popular commercial iOS Chart library was tested (labelled CompetitorA) which had comparable performance to “Charts”. 
  • Finally, the fastest iOS Chart was SciChart for iOS, which beat all tested iOS Chart Controls by a wide margin.

At smaller datasets all the charts appeared fine, however once we increased the volume of data and rate of updating the iOS Chart control, all of the above slowed down significantly except for SciChart iOS. In all tests SciChart for iOS registered between 2-3x faster than the nearest competitor, and in one, a staggering 30x faster.

How to we measure iOS Chart Performance?

iOS Chart Performance is really important to us at SciChart. We strive to have the best, and the fastest Charting controls in the world, but how do we demonstrate what we’ve achieved vs. our competitors to would-be customers? We have developed a comparison application which generates several different chart types and measures refresh rate (FPS – Frames per Second) for several different iOS Chart Libraries. We also included such numbers like CPU usage and Start time. This is then used to draw conclusions about the performance of various iOS Chart Libraries vs. our own iOS Charts.

We’ve created an application which measures our Chart Performance in a number of scenarios, such as line, scatter, scrolling-line and many-series scenarios. The tests are designed to really stress the chart control and find it’s limits.

There there are several factors which influence overall performance of a iOS Chart Control. Such as:

  • Number of Series in the chart
  • Types of Series (e.g. Line, Scatter, Area, Candlestick)
  • Number of data-points per series
  • Rate of change of data (number of points appended or removed per second)
  • Thickness of pens / number of pixels filled
  • Number of transformations between data & pixel coordinates per second
  • Any additional calculations like Auto Ranging

These are reflected in the test cases and show stress on different areas of the renderer.

Who did We Compare Against?

We have compared the performance of iOS Charts by SciChart against the some popular and renowned iOS charting libraries, including:

  • Charts, an open source cross-platform charting software library for iOS and Android
  • Competitor A, a popular commercial cross-platform Android and iOS charting software

We also had a look at

  • CorePlot, an open source graph plotting library for iOS

However due to time constraints, plus poor stability and performance of these libraries when large data was appended, we have omitted them from the results – for now.

The Test Setup

What Tests are Run

A number of tests are run in our iOS Chart Performance Comparison app which stress different areas of the renderer. These tests are designed to really stress the chart, by having huge numbers of series, or points, or many updates per second.

A certain test is run, and FPS, or refresh rate, is measured via the CADisplayLink , which fires once after each drawing pass completes.

Test Setup Hardware

For the Test Setup we have used iPhone 5s

The test cases are as follows:

Test 1: NxM Series Test

IMG_0185-577x1024_iphone6_silver_side1
SciChart Performance Test1: NxM Series N series of M points are appended to an XyDataSeries, then the chart redraws (the same data) as fast as possible.

FPS is measured using the time elapsed between subsequentSciChartSurface.Rendered events.

Areas Stressed:

      Iterating Data Series

      Coordinate Transformation

     – Drawing.

 

 

 

Test 2: Scatter Series Test

IMG_0188-577x1024_iphone6_silver_portrait
SciChart Performance Test2: Scatter Series

N Scatter points are appended to a XyDataSeries, then the chart redraws.

Immediately after, the points are updated in a Brownian motion fashion and the chart is drawn again.

The FPS is measured using the time elapsed between subsequent SciChartSurface.Rendered events.

Areas Stressed:

– Coordinate Transformation

– Geometry Generation (Ellipse)

– Drawing.

 

Test 3: FIFO Series Test

IMG_0193-577x1024_iphone6_silver_side1
SciChart Performance Test3: Fifo Series

N points are appended to a FIFO (circular buffer) series, then a single point is appended (and one dropped), which triggers a redraw of the chart.

The FPS is measured using the time elapsed between subsequent SciChartSurface.Rendered events.

Areas Stressed:

– Copying Circular Buffers (FIFO Series)

– Resampling

–  Drawing.

 

 

 

Test 4: Append Data Test

IMG_0198-577x1024_iphone6_silver_side2
SciChart Performance Test4: Append
N points are appended to DataSeries, then M points are appended between each draw of the chart.

Areas stressed:

– Appending Data

– Resampling

– Auto-Ranging

– Drawing.

 

 

 

The Test Results

We’ve included the test results below:

  • All test result numbers are in FPS (Frames per second), meaning, the average number of redraws per second during the test (Higher Numbers are better!)
  • We also included CPU usage (smaller is better!)
  • And Start Time in seconds (smaller is better!)

 

In Table Form

You can find the test results of our iOS Chart Performance Comparison below. All test result numbers are in FPS (Frames per second – Higher is Better), meaning, the average number of redraws per second during the test, as measured by CADisplayLink . We have also included start time and CPU usage – Smaller is Better for both. 

If a number is missed (blank), it means that a chart failed to run (crash) under a particular test-case.

comparisontable

Test Results in Chart Form

What iOS charting performance comparison would be complete without the results in chart form?

You can find the test results plotted below:

Append Points Test Results

SciChart iOS is blue, results are FPS (Refresh rate) so higher is better.

Append_Data

Fifo Scrolling Test Results

SciChart iOS is blue, results are FPS (Refresh rate) so higher is better.

FIFO_charts

Scatter Series Test Results

SciChart iOS is blue, results are FPS (Refresh rate) so higher is better.

ScatterSeries_Charts

NxM Series Test Results

SciChart iOS is blue, results are FPS (Refresh rate) so higher is better.

NxMSeries_Charts

Performance Comparison Conclusions

According to the Performance Comparison Results, Most iOS Chart libraries are unsuitable for real-time updates on the chart. Most perform poorly once the amount of data reaches a few thousand points.

By contrast, the iOS Charts by SciChart are extremely fast and show robust performance across a number of test cases including scatter charts, scrolling line series, appending line series and multiple series.

SciChart should be considered a very strong contender when evaluating real-time iOS Charting Libraries for use in  iOS Apps.

A version of the test-application is available on request, if you would like to contact us. For legal reasons we can’t publish the names of Competitor A, but if you believe you are that competitor and wish to verify the results or submit a modification to optimize your code, please feel free.

Information about second competitor – “Charts” – you can find here.

Finally let us know what you think in the comments! If there’s anything else you want us to test, please ask!

Best regards,
Yaroslav,
SciChart Team

The post How Fast is SciChart’s iOS Chart? appeared first on WPF Charts, iOS and Android Charts | SciChart.


Read more »




CONTACT US

Not sure where to start? Contact us, we are happy to help!


CONTACT US

SciChart Ltd, 16 Beaufort Court, Admirals Way, Docklands, London, E14 9XL. Email: Legal Company Number: 07430048, VAT Number: 101957725