Benchmarks Put Android 2.2 at Wicked Fast…Like 450% Faster Than 2.1


Alright so let’s preface this with the whole “take it for what it’s worth” deal.  The guys over at AndroidPolice have been playing with the Froyo (2.2) build of Android and decided to do some benchmark testing.  They are using an application called Linpack which measures efficiency and speeds in “Millions of FLoating-point Operations Per Second (MFLOP)”.  The idea here is that the higher number you can get, the better.

For comparison sake, here’s what the AndroidPolice have found:

  • Nexus One running Android 2.1 gets about 6.5-7 MFLOPS
  • HTC Hero averages a measly score of about 2 MFLOPS (the phone is pretty slow indeed)
  • And the Nexus One with Android 2.2 (Froyo)…37.5 MFLOPS.

Rudimentary math says that’s about 4.5 times the 2.1 figure.  We have no way of verifying any of this, nor do we pretend to be experts at flops and linpacks.  The bottom line here is that Froyo is fast.  It appears Google has done some things to optimize the platform well beyond simply adding Flash.

Thanks Artem!


  1. This is expected due to Android being switched to a JIT-compiler. Java byte-code is compiled to native code once before execution, as opposed to interpreting the byte-code every time that part of the code is run. It has exactly this kind of effect on Java applications. Note that it doesn't effect the speed native code is run at. Apps which already use native libraries for heavy calculations will only see improvements in the small parts that are run in Java.

    see for example

  2. Great news. Definitely will speed up most apps that are java interpreted. But for games and theoretical 3D game performance, probably not much gains since those games are already running in native code.

  3. Hmm, interesting.

    However, such increase in performance is a little bit weird. I'm currently developing a comprehensive benchmarking application for Android and I also incorporated Linpack there (which is/was a standard floating point benchmark). However, I made both native and java ports of this benchmark.

    The results I observed on my HTC Magic is that native code is roughly 2-3 times faster than java code running on Dalvik. I would expect it to be similar on Nexus One. So without running the same code natively, it's hard to interpret those results. Note that JIT can be smart enough to skip whole parts of code, especially those that get repeated in loop and don't produce side-effects. So without knowing how this application works, it's hard to say anything conclusive.

    • The issue is that floating point on the NDK does not utilize the VPU (float point processor) of the ARM cpu; while Java code does. Therefore, a 5.5x speed improvement via Java with a JIT is certainly possible, and would make Java code faster than native code for many applications…that is until the NDK can properly compile floating point.

      • As far as I know Android uses softfp, so all floating point operations result in calls to C routines from shared library. This library uses software emulated float operations for hardware without VFP. But for devices with VFP it uses real hardware floating point operations (at least it should). This method introduces additional overhead, but this way your code will utilize hardware floats if it's supported by hardware and will still run fine in the absence of VFP.

        Now, if I'm wrong and this is not the case, then things get a little more complicated and it may be as you wrote. Guess I'm gonna have to check that for myself, as soon as I get my hands on some VFP enabled device.

  4. I like how you used a lot of maybes in this news but from an user experience perspective, this benchmark really means nothing…