codedivine

It is a simple memory bandwidth benchmark application for Android. Simply install, press "Run" and it will give you a score for achievable memory bandwidth.

Alternately, you can try out various settings such as number of threads. You can also run the "Misc" tests which are a variation of the STREAM benchmarks. The "Simple" simply tests the memcpy performance.

edit: Some scores. 1.25 GB/s on Samsung Hummingbird processor. 1.8GB/s on the previous-gen dual-core Snapdragon.

Yes, same with my NDK based apps though in my case I have only compiled for x86 and ARMv7-A. About MIPS, is there any MIPS based hardware with Play store access out there that we need to worry about?

Btw you may want to know that there is a bug in 4.0.3 that sometimes loads armeabi code instead of armv7-a code on some ARMv7 systems like HTC One S.

Thanks. Good to know it is consistent with what other users reported to me :)

Well, for anyone interested in Cling, check out this Google tech talk: http://www.youtube.com/watch?v=f9Xfh8pv3Fs

This is a CERN project and it uses Clang from the LLVM project. The idea is simple: use the clang to generate LLVM and then use LLVM just-in-time compiler.

No discussion about this?

when people use iPads they end up just using technology to consume things instead of making things. With a computer you can make things. You can code, you can make things and create things that have never before existed and do things that have never been done before.

I think closed devices are really a step backwards. I learnt programming (and a whole lot more, like mathematics and logic), when I picked up a computer as a kid and discovered Python and started hacking around. I could look around for tutorials, download code or try out code from books and nobody stopped me.

On a somewhat similar vein, I am also sad that desktops are slowly going away. I learnt so much more about computers (and how it is not magic) by building my own.

I think something needs to be said about systems that allow you to explore and hack around for the fun of it.

I think the assumption that Moore's law, or even Koomey's law, is going to hold for another two decades is wildly optimistic. I would expect a taper off much sooner, perhaps even this decade.

The physics and the economics of smaller process nodes is becoming harder and harder, to the point where anything beyond 10nm or so looks extremely difficult.

Well Qt is simply a C++ API and as such can become a standard part of the Android NDK if Google chooses.

Its not "yet another integration", Qt is already the base component of their Cascades framework which is RIM's preferred way of building BB10 apps.

Well Qt doesn't require X11. Qt's backends are actually VERY flexible, essentially all you need to do is provide it with a 2D drawing surface in most cases.

There is already an Android port of Qt in progress here, with a lot of things (including Qt Quick and QWidgets) already working: http://sourceforge.net/p/necessitas/home/necessitas/ Several apps using Qt have already been published in Google Play.

Well, two points:

1. Using raw pointers as opposed to vectors gives 2x the performance on my machine.

2. This is a microbenchmark with extremely simple array indexing pattern. JVMs can optimize away the array bounds checks penalty in this case but those become hard to do once your access patterns become anything other than "i" or "i-1". For example, even more general linear subscripts are hard to correctly optimize for array bounds checks, let alone anything non-linear. How do I know? Compiler researcher here :)

However, still impressive to see JVMs advance.

True, but bear in mind that third-party apps still have limitations such as no JIT compilation, that hurt the JS performance of third-party browsers. Safari does not have this limitation which gives it an unfair advantage.

Qt 5 work on Android looks to be highly experimental at this stage. You should look at Necessitas project. Qt 4.8 works fine for the most part, though apps that do 3D work through OpenGL don't always work due to limitations in Android GL stack. Non-OpenGL apps should work fine with several Qt apps that I know of in Google Play already.

Qt (especially Qt 5) is one of the most portable toolkits out there, its almost like Webkit in that respect. Lot of excellent work has been done in Qt 5 (and Qt 4.8) to make it easy to port to any platform with minimal dependencies. It already works on Windows (albeit Win32, not WinRT), Linux (X11, Wayland as well as almost pure Qt), OSX, QNX.

Sure, it is still not a one-click task, but that can never be the case. I think Qt has a bright future simply because it is essentially unkillable at this point. (Open-source licensing, open governance already in place, highly portable).