I have the feeling that we share different ideas of types of performance tests. It depends on what you plan to measure. Is it the “overall” performance or specific parts of the whole picture?

Regarding this string-concatenation issue: I think I already mentioned multiple times that there is no StringBuffer class in Flash. Thus, I basically did two tests:

1) Comparison between Flash and Silverlight using the (+)-operator

2) Comparison between Flash and Silverlight using the StringBuffer class and a self-written implementation in AS3 for Flash.

Because the result of the string concatenation with the plus operator is identical for Flash and Silverlight does not mean that they are technically the most performant ways of concatenating strings. So you will make performance tests cause of syntactical equality. That’s completly weird.

It’s like making a race between an old beetle and an Ferrari and say to the Ferrari driver he is only allowed to drive in the first gear. And at the end you are wondering that the beetle has won.

Restricting the Ferarri driver like this is what you do if you use the plus operator for string concatenation in Silverlight. You will get the worst results for performance. If someone want to make serious performance comparisons he has to use the most performant techniques for each category and not that one that are syntactical the most equal.

If Martin wants to use the “best” technique for each platform as a means of benchmarking, rather than using apples to apples, then I would suggest he should write a copyPixels() example for his Bubblemark test that creates balls which extend BitmapData.

Unfortunately, I am almost done with my thesis and thus cannot do much changes any more.

Regarding the additional options, the StringBuffer classes offer, you’re right. AS3 does not offer this (as far as I remember). There is no StringBuffer class anyway – You have to build it on your own using Arrays or Vectors.

I cannot back up your claim that languages like AS3 or JS are easier to handle. I personally, think that especially JavaScript is a true nightmare regarding syntax and debugging issues compared to compiler-aided languages like C# or Java.

Thanks for your tips regarding the rendering engine but I fear that most of these (blur effects, resize transformations etc.) do not apply for my benchmark. My test simply creates a shitload of small rectangles on a canvas and moves them around. Not more and not less.
Further: I want to avoid any caching-techniques because otherwise the results between the different RIA runtimes are not 100% comparable (imho).

maybe it’s actual a minus for Silverlight and JavaFX, because someone who is new to these frameworks hardly knows such issues.

Programming languages like AS3 and JavaScript may be easier to handle, but on the other hand you lost a bit of control over the things, that are happening in the background. For example the StringBuilder in Silverlight gives you the possibility to define the char capcity and therefore influence the memory usage of your string. Does AS3 gives you such a influence to their strings? I don’t know really, but I doubt AS3 will do.

So there are advantages and disadvantages in my opionion.

Regarding the Silverlight rendering engine I am also not much experienced. I made a few fun projects with graphics and animations in Silverlight. I was taken to a couple of performance problems while I was developing. First I would suggest to you to take a look to the Silverlight performance tips from Microsoft:

http://msdn.microsoft.com/en-us/library/cc189071%28VS.95%29.aspx

Furthermore I can gave you some tips based on my experience with Silverlight:

* Use always canvas controls as LayoutRoot and for your parent controls that contains your elements you want to animate/render.
* Avoid animating properties like width or height of controls. Instead use ScaleTransform.
* Avoid animation elements/controls via Canvas.SetLeft or Canvas.SetTop. Use TranslateTransform.
* Avoid to render elements yourself via CompositionTarget.Rendering. Instead let Silverlight do the rendering.
* Avoid performance consuming calculations in the UI thread. This may reduce your framerate.
* PixelShader effects like the blur effect will need much performance, because they are rendered via software.
* Use Hardware-Acceleration to boost the performance via caching. But keep in mind that in some special cases the caching might decrease the framerate, so do not cache elements blindly. An example for this might be particle effects. Use EnableCacheVisualization to dertimine whether elements are cached or not.
* Use EnableRedrawRegions to see which elements are rendered all the time, although it’s not needed. For example try to avoid changing transformations parameters of elements, although no or minor changes of the values are made.

These are a few things I ecountered. There are propably more things to know, but for this someone has to go deeper into the matter :-) But I hope the things above will help you a bit.

thanks for your post!

After reading Martin’s comments about the StringBuffer-classes, I included those into my benchmarks. The string-concatenation related tests now exist in 3 variants:
– Using the (+) operator
– Using the str.concat(str1) methods
– Using a StringBuffer

So far, it seems like the StringBuffer gives a huge boost to Silverlight, as well as JavaFX applications. On Flash and JavaScript, almost no changes could be observed. Using the (+)-operator here lets them perform almost as good as the Silverlight- and JavaFX-versions utilizing StringBuffer. It’s interesting to see how these runtimes perform very well (regarding the string-concatenation operation) even without a StringBuffer. Isn’t that actually a minus for Silverlight and JavaFX if they rely on such classes if Flash and JavaScript work well without them? :-)

Regarding your comments about my knowledge on the .NET framework and its rendering engine, you’re partially right. I’m not THE Silverlight-guru claiming to know everything about this technology. What I basically did was, building a reference design in Flash and then port it to other runtimes. If you have any suggestions about things I should know, which are absolutely vital for this issue, you’re welcome to post here :-)

I read your article and your comments with interest. With all due respect for me it looks like you lack experience of the .NET technology. The technical background for the .NET string concatenation like Martin explained is some fundamental you have to know, if you want to make performance tests with strings.

And for the rendering in Silverlight there are also issues you should know. Well, you can easily write .NET code in Silverlight that works just fine, but it can be code that performs badly. It’s not unusual for someone which is not that experienced with a technology to write such code, but it’s important if you want to make a performance comparision like you want to do.

I am looking forward to the publication of your final results and your source code.