![]() |
Roy Longbottom's Android Benchmark Apps
|
![]() |
Java Whetstone ResultsThe first measurements obtained were via emulators running on a 3 GHz quad core Phenom, the benchmark only using one core, of course. They suggest a slightly slower performance using a screen with a higher pixel density and much better performance with a later Android version and/or a more modern CPU. Based on comparisons with CPU MHz, v7-A8 CPUs are faster than the ARM 926EJ CPU, due to VFPv3 enhanced floating point hardware, and in turn, v7-A9s are even faster. Performance of P8, with the Qualcomm MSM8960 CPU, is superior to these ARM devices. Some of the v7-A9 resulrs are not proportional to CPU MHz, where calculations suggest that that 1300 MHz T7 and 1500 MHz T4 are running at 1200 MHz. This was confirmed later, using a new program. See Measure CPU MHz. August 2013 - Cortex-A15 based tablet T11 (really running at 1700 MHz) has the fastest speeds, at this time. On a per MHz basis, it outperforms Cortex-A9 by 30% to 40%, except on the mathematical function tests (headed COS and EXP) where performance is similar.
The last two sets of results are for the same Java code running on Intel CPUs under Linux and via Android x86.
These use different JIT compilers, voiding comparisons with the other Android results.
Java Numeric ResultsBoth emulated and real numeric results using ARMv7 are different from ARM926EJ for some floating point calculations. This is not unusual for different compilers or types of processor and is due to variations in instruction sequences or hardware rounding arrangements. It looks as though these two processors are not logically identical or program optimisation procesures are different.
ARMv7 P3 has enhanced architecture that probably changes the calculated results of the lasts test.
Results from Native Code versions are also provided.
|
System ARM MHz Android MWIPS ------MFLOPS------- ------------MOPS-------------- See CPU Build 1 2 3 COS EXP FIXPT IF EQUAL T1 @5 926EJ 800 2.2 31.2 10.2 10.2 11.4 0.6 0.3 38.8 278.4 219.4 T1 @7 926EJ 800 2.2 30.3 10.2 9.3 11.5 0.6 0.3 39.0 293.5 220.1 T2 @5 v7-A9 800 2.3.4 170.9 20.4 21.4 28.4 7.6 2.2 85.5 756.0 764.3 T2 @7 v7-A9 800 2.3.4 687.4 165.4 149.9 153.4 15.9 9.3 723.1 1082.1 725.3 T4 @7 v7-A9 1500a 4.0.3 1129.3 272.7 250.0 256.4 25.5 15.1 1197.5 1789.3 1190.7 T4 CPU Norm 1500 4.0.3 650.6 35.4 237.5 164.4 11.3 14.2 405.3 1468.9 1174.5 T4 CPU Norm 1500 4.0.3 203.1 46.2 90.7 53.8 3.9 2.7 221.6 199.1 472.3 T6 @7 v7-A9 1600 4.0.3 1514.6 350.3 330.9 339.2 35.0 20.5 1583.4 2355.5 1582.8 T7 @7 v7-A9 1300a 4.1.2 1115.0 271.3 250.7 256.4 25.8 14.6 1190.0 1797.0 1198.7 T11 @7 v7-A15 2000b 4.2.2 1477.7 363.9 220.6 307.5 39.7 18.0 1690.5 2527.9 1127.9 T13 @7 v7-A9 1400c 4.1.2 808.9 209.0 162.3 204.3 17.2 11.3 854.5 1273.2 906.6 T13 @7 v7-A9 1400 4.1.2 1180.6 303.5 283.5 264.3 28.8 14.4 1358.9 2998.2 1282.2 P8 @7 QU-S4 1500 4.0.3 1039.5 255.7 316.5 299.6 20.2 13.2 1503.6 1795.2 1504.2 P9 @7 v7-A8 1000 2.3.5 288.2 95.0 83.8 87.6 5.8 3.5 389.6 929.5 228.5 P11 @7 v7-A9 1400 4.0.4 1333.6 315.5 291.2 298.6 39.8 18.1 1394.7 2089.9 1395.5 Measured MHz a=1200, b=1700, c=power saving EP1 @5 926EJ Emul 2.2 20.1 7.0 6.7 9.3 0.4 0.2 30.9 218.6 98.5 ET2 @5 v7-A8 Emul 4.03 43.7 7.2 7.0 9.3 1.1 0.6 30.8 225.1 100.9 ET2 @7 v7-A8 Emul 4.03 96.7 37.0 32.1 36.1 1.6 1.3 121.9 238.4 216.4 BS1 Emul Ph 3000 2.3.4 103.6 36.9 32.6 37.7 1.8 1.4 130.2 414.0 374.1 Atom 1666 Linux 769.0 330.0 333.0 282.0 17.1 7.2 968.0 1143.0 1149.0 Core 2 2400 Linux 2560.0 865.0 885.0 589.0 65.7 29.1 3851.0 5314.0 1078.0 System - T = Tablet, P = Phone, E = Emulator, @7 for vfpv3 FPU, QU = Qualcomm CPU CPU Norm = ICS Settings, Developer Options, CPU Mode, Normal - other T4 = Performance |
Results are also shown for Linux C compilations on two Intel processors.
In this case, the A9 CPU at 1500 MHz has a better overall score than the 1666 MHz Atom. This is due to the faster tests using such as Cos and Exp functions.
The Linpack Benchmark was produced from the "LINPACK" package of linear algebra routines. It became the primary benchmark for scientific applications, particularly under Unix, from the mid 1980's, with a slant towards supercomputer performance. The original double precision C version, used here, operates on 100x100 matrices. Performance is governed by an inner loop in function daxpy() with a linked triad dy[i] = dy[i] + da * dx[i], and is measured in Millions of Floating Point Operations Per Second (MFLOPS). Two versions use a Java front end, again providing Run, Info and Save buttons, with the main C code compiled by Android Native Development Kit. A third comprises the same front end with Java code for Linpack calculations. They are Linpackv5.apk (LP5), using old, slow instructions, Linpackv7.apk (LPK) to use faster vfpv3 hardware and LinpackJava.apk (LPJ) that depends on a suitable Runtime Environment. A fourth variety, LinpackSP.apk (LPsp) is also available, comprising the C version compiled to use single precision floating point. The .apk application files can be downloaded from:
www.roylongbottom.org.uk/Linpackv5.apk and www.roylongbottom.org.uk/LinpackJava.apk
www.roylongbottom.org.uk/Linpackv7.apk and www.roylongbottom.org.uk/LinpackSP.apk
Further details of the Linpack benchmark, and results from Windows and Linux based PCs, can be found in Linpack Results.htm. The Java version has the same calibration calculations as my C program but the uses the Code from Netlib for the calculations, as C uses different function calling conventions.
Output results provide the same System Information as shown for the Whetstone Benchmark, preceded by MFLOPS speed and numeric results, examples being shown below.
In this case, calculations from the double precision versions produce the same numeric results, with differences using single precision functions. These are also identical to those from Microsoft Visual C under Windows and Linux using 64-Bit GCC on PCs, with other compilers used producing differences.
Android Linpack v5 Benchmark Android Java Linpack Benchmark Speed 10.56 MFLOPS Speed 33.36 MFLOPS norm. resid 1.7 norm. resid 1.7 resid 7.41628980e-14 resid 7.41628980e-14 machep 2.22044605e-16 machep 2.22044605e-16 x[0]-1 -1.49880108e-14 x[0]-1 -1.49880108e-14 x[n-1]-1 -1.89848137e-14 x[n-1]-1 -1.89848137e-14 Same Android Linpack v7 Benchmark Android Linpack v7SP Benchmark Speed 101.39 MFLOPS Speed 129.05 MFLOPS norm. resid 1.7 norm. resid 1.6 resid 7.41628980e-14 resid 3.80277634e-05 machep 2.22044605e-16 machep 1.19209290e-07 x[0]-1 -1.49880108e-14 x[0]-1 -1.38282776e-05 x[n-1]-1 -1.89848137e-14 x[n-1]-1 -7.51018524e-06 Same Different Android x86 Java on Core 2 Android x86 Java on Atom Speed 53.27 MFLOPS Speed 15.65 MFLOPS norm. resid 1.8 norm. resid 1.8 resid 8.03801470e-14 resid 8.03801470e-14 machep 2.22044605e-16 machep 2.22044605e-16 x[0]-1 3.55271368e-14 x[0]-1 3.55271368e-14 x[n-1]-1 3.44169138e-14 x[n-1]-1 3.44169138e-14 Different Different |
MFLOPS results for the four Android versions are provided below. Also shown are those for PCs, compiled for Windows and Linux, the benchmarks being downloadable via Linpack Results.htm. Java results for PCs were from using Linpack Java Applet from Netlib and Android x86.
The most popular Android Linpack benchmark appears to be from GreeneComputing. This is a Java variety and produces similar performance ratings to my LinpackJava on T1 and T2 as quoted below. The former also has a multi-processor test but it is not clear whether it uses multiple threads on a single program, or multiple copies of the program, where results and not really representative for comparing with published MP speeds.
Using compiled C programs a Cortex-A9 can be nearly as fast as an Atom running at the same MHz, but this is not the case with Java. Unlike Intel, it seems that the double precision version can be much slower than using single precision calculations.
The T4 and T7 v7-A9 CPUs again appear to be slow at 1200 MHz but T2, T6 and P11 seem to be at full speed. The Qualcomm CPU performs well on this benchmark.
August 2013 - Tablet T11, with the Cortex-A15 CPU, runs at 2.5 times the speed of an A9 processor of the same MHz (if one existed), using the most recent floating point instructions. Linpack benchmark results are often quoted for ARM based systems, probably a design consideration.
The benchmark code has been modified to use NEON intrinsic functions that carry out four arithmetic operations simultaneously. See
android neon benchmarks.htm . For the new benchmark
Download NEON-Linpack.apk.
Results from this are included below.
The Dhrystone "C" benchmark provides a measure of integer performance (no floating point instructions). It became the key standard benchmark from 1984, with the growth of Unix systems. The first version was produced by Reinhold P. Weicker in ADA and translated to "C" by Rick Richardson. Two versions are available - Dhrystone versions 1.1 and 2.1. The second version, used here, was produced to avoid over-optimisation problems encountered with version 1, but some is still possible. Because of this, optimised and non-optimised compilations are provided. Speed was originally measured in Dhrystones per second. This was later changed to VAX MIPS by dividing Dhrystones per second by 1757, the DEC VAX 11/780 result, the latter being regarded as the first 1 MIPS minicomputer.
The optimised .apk app file (DS2) can be downloaded from www.roylongbottom.org.uk/Dhrystone2.apk and the non-optimised one (DSN) from www.roylongbottom.org.uk/Dhry2Nopt.apk. Further details of the Dhrystone benchmark, and results from Windows and Linux based PCs, can be found in Dhrystone Results.htm.
The same format Java front end, described above, is used, with the two C programs compiled using Android NDK. Examples of results is below, the Emailed version including the standard System Information.
Dhrystone 2 Benchmark 10-Feb-2012 19.08 Dhry2 NoOpt Benchmark 14-Feb-2012 12.15 Nanoseconds one Dhrystone run 592 Nanoseconds one Dhrystone run 1244 Dhrystones per Second 1689546 Dhrystones per Second 804020 VAX MIPS rating 962 VAX MIPS rating 458 |
Unlike when using floating point, on this benchmark, the Cortex-A9 CPU is less than three times faster than the 926EJ on all measurements, a ratio similar to that provided by the BogoMIPS results, shown in System Information. Measurements for Intel Atom and Core 2 CPUs are also provided for Windows (Watcom 32 Bit) and Linux (GCC 32 Bit and 64 Bit) compilations. Core 2 results show considerable variations, highlighting the Danger, in comparing results from different compilers. In this case, the significant difference is between 32 and 64 bit compilations under Linux, where far more registers are available for optimisation at 64 bits. On using them, the compiler might decide that multiple passes are not needed and remove repetitive calculations. Also, historically, computer manufacturers are known to have optimised their own compilers to inflate speeds of standard benchmarks.
Here, the optimised benchmark produces up to 1.4 Vax MIPS/MHz for the Cortex-A9. ARM, themselves, quote 2.5 Vax MIPS (DMIPS) per MHz for the same processor, probably just another different compiler variation.
Note the speed on tablet T5. This uses a MIPS CPU and requires an emulator to execute compiled ARM processor instructions. T5a results are for an identical tablet, from a different user, but with no details of settings used. The T4 and T7 v7-A9 CPUs again appear to be slow at 1200 MHz but T2 and P11 seem to be at full speed.
August 2013 - Tablet T11, with the Cortex-A15, is 30% to 40% faster than would be expected from the last generation of ARM processors.
Below are other results from http://gamma0burst.tistory.com in Korea (including some of mine). These provide better identification of the processors used. There are wide variations in results of what should be identical CPUs but, as with all benchmarks reported here, the systems might not be running at the specified clock frequency or might need a Setting to run at maximum speed.
Opt No Opt System ARM MHz Android Vax Vax Bogo See MIPS MIPS MIPS T1 926EJ 800 2.2 356 196 798 T2 v7-A9 800 2.3.4 962 458 2036 P13 v7-A9 1200 4.1.2 1491 1592 P14 v7-A93 ? 4.2.3 645 2000 T4 v7-A9 1500a 4.0.3 1650 786 2394 T7 v7-A9 1300a 4.1.2 1610 810 1994 T11 v7-A15 2000b 4.2.2 3189 1504 998 P11 v7-A93 1400 4.0.4 1937 866 2786 EP1 926EJ Emul 2.2 227 122 ET2 v7-A8 Emul 4.03 286 160 Measured MHz a=1200, b=1700 T5 MIPS CPU 1000 4.01 56 1006 T5a MIPS CPU 1000 4.01 213 1006 T5a MIPS CPU 1000 4.01 70 1006 BS1 Emul Ph 3000 2.3.4 484 BS2 Emul C2 1833 2.3.4 150 32 Bit Atom 1666 Linux 2055 1194 64 Bit Atom 1666 Linux 2704 1098 32 Bit Atom 1666 Windows 1948 780 32 Bit Core 2 2400 Linux 5852 3348 64 Bit Core 2 2400 Linux 12265 3288 32 Bit Core 2 2400 Windows 6466 1251 System - T = Tablet, P = Phone, E = Emulator Processor MHz Cores VAX MIPS MIPS /MHz Sam Exynos 4210 Cortex-A9 1200 2 1491 1.24 1200 2 1900 1.58 1400 2 1450 1.04 Sam Exynos 4412 Cortex-A9 1400 4 1740 1.24 1400 4 1937 1.38 Aml AML 8726-MX Cortex-A9 1500 2 1650 1.10 TI OMAP 4430 Cortex-A9 1200 2 1409 1.17 1200 2 1662 1.39 nV Tegra 3 Cortex-A9 1300 4 1610 1.24 Sam Exynos 5250 Cortex-A15 1700 2 3200 1.88 1700 2 3687 2.17 QSn S1 QSD 8250 Scorpian 1000 1 880 0.88 QSn S4 APQ 8064 Krait 1500 4 2417 1.61 1500 4 2555 1.70 QSn S4 APQ 8064T Krait 1700 4 2563 1.51 QSn S4 MSM 8960 Krait 1500 2 2229 1.49 QSn - Qualcomm Snapdragon, Sam - Samsung, Aml - Amlogic, Ti - Texas Instruments, nV - nVidia |
This original main benchmark for supercomputers was first introduced in 1970, initially comprising 14 kernels of numerical application, written in Fortran. This was increased to 24 kernels in the 1980s. Performance measurements are in terms of Millions of Floating Point Operations Per Second or MFLOPS. The kernels are executed three times with different double precision data array sizes. Following are overall MFLOPS results for various systems, geometric mean being the official average performance. [Reference - F.H. McMahon, The Livermore Fortran Kernels: A Computer Test Of The Numerical Performance Range, Lawrence Livermore National Laboratory, Livermore, California, UCRL-53745, December 1986]
---------------- MFLOPS --------------- CPU MHz Maximum Average Geomean Harmean Minimum Measured in CDC 6600 10 1.1 0.5 0.5 0.4 0.2 1970 * CDC 7600 36.4 7.3 4.2 3.9 2.5 1.4 1974 * Cray 1A 80 83.5 25.8 14.4 7.9 2.7 1980 * Cray 1S 80 82.1 22.2 11.9 6.5 1.0 1985 CDC Cyber 205 50 146.9 36.4 14.6 5.0 0.6 1982 * Cray 2 244 146.4 36.7 14.2 5.8 1.7 1985 Cray XMP1 105 187.8 61.3 31.5 15.6 3.6 1986 * Fewer than 24 Kernels
For Cray 1 comparison purposes, it is more appropriate to use Cray 1S results, as these are from running all 24 kernels. See below for best results so far, currently T4 using one of the two 1500 MHz cores, where performance equates to 15.5 times a Cray 1. Cost of this tablet was $130, in May 2012. Cray 1 was $7M.
The benchmark execution file can be downloaded from www.roylongbottom.org.uk/LivermoreLoops.apk. Further details of the Livermore Loops benchmark, and results from Windows and Linux based PCs, can be found in Livermore Loops Results.htm.
The same format Java front end, described above, is used, with the C program compiled using Android NDK. An example of results is below, the Emailed version including the standard System Information.
800 MHz ARM Cortex-A9 Android Livermore Loops Benchmark 12-Feb-2012 21.55 MFLOPS for 24 loops Do Span 471 172.6 127.5 253.2 248.6 71.6 141.2 197.6 190.4 202.3 109.2 55.2 51.2 54.1 51.5 100.0 144.1 192.1 139.4 130.1 105.4 111.2 63.1 136.3 56.8 Overall Weighted MFLOPS Do Spans 471, 90, 19 Maximum Average Geomean Harmean Minimum 253.2 129.3 115.3 101.6 46.7 Results of last two calculations 4.850340602749970e+02 1.300000000000000e+01 Total Elapsed Time 11.9 seconds |
So far, numeric results of the last two calculations have been identical on all benchmark runs.
System T2, with the high speed vfpv3 hardware, is again shown to be around 20 times faster than the tablet T1, on these floating point calculations. Relative to CPU MHz, T2 performs better than v7-A9 CPUs T4 and T7 and P8 Qualcomm, but P11 outshines them all. This benchmark has some L2 cache speed dependency. This cache is shown to be particularly fast on later benchmarks.
August 2013 - again, it is pointed out that tablet T11, with the Cortex-A15, is really running at 1700 MHz (not 2000), and some Cortex-A9s, used for comparison, are at 1200 MHz. This A15 is the first ARM processor to demonstrate more than 1 GFLOPS, on this benchmark. On a per MHz basis, the results demonstrate a wide range of relativity to A9s, varying from slighly slower to 3.4 times faster, the official average showing an improvement of 50%. Then, the system is also running at a higher MHz.
This benchmark is one of those that failed to use fast vfpv3 hardware under Android 4, Ice Cream Sandwich. In this case, a revised compilation procedure lead to the hardware being used with appropriate faster performance. The procedure was to compile a program that used vfpv3, then replace the Java and C code with that for the benchmark (see below).
This benchmark measures data reading speeds in MegaBytes per second carrying out calculations on arrays of cache and RAM data, sized 2 x 8 KB to 2 x 32 MB. Calculations are x[m]=x[m]+s*y[m] and x[m]=x[m]+y[m], using double and single precision floating point and x[m]=x[m]+s+y[m] and x[m]=x[m]+y[m] with integers. Million Floating Point Operations Per Second (MFLOPS) speed can be calculated by dividing double precision MB/second by 8 and 16, for the two tests, and single precision speeds by 4 and 8. Assembly listings for integer tests show that Millions of Instructions Per Second (MIPS) can be found by multiplying MB/second by 0.78 with 2 adds and 0.66 for the other test. Cache sizes are indicated by varying performance as memory usage changes.
Results below show maximum MFLOPS and MIPS speeds. The first integer test loop has 25 assembler type instructions, comprising 8 loads (x 4 bytes), 11 adds (8 data, 2 addresses, 1 loop increment), 4 stores, 1 compare, 1 branch), or an instructions/bytes ratio of 0.78125. Best Cortex-A9 MIPS/MHz ratio is 1.59.
Using L1 cache data, performance differences on Cortex CPUs are similar to the benchmarks above. In the case of the Qualcomm Snapdragon, floating point tests are significantly faster, relative to CPU MHz, but a little slower using integers. Other than comparisons with the Snapdragon CPU, P11, the Galaxy SIII, provides a significant performance gain using L2 cache. This might be due to the claimed use of 128-bit internal buses, instead of 64-bit. The most outstanding results for P11 are using memory, typically three times faster than other A9s, and these might be aided by the L2 cache arrangement. P11 is said to have dual channel memory and, although not always stated, others have a single channel (see Memory and Bus Speed Calculations below).
August 2013 - T11, with the Cortex-A15, provides the fastest speeds reported here. Again, more than 1 GFLOPS is demonstrated, but this time with single precision calculations. Compared with P11, the last leader, and adjusting to compare at the same clock speed, memory speeds are similar, but the T11 is 2 to 3 times faster on double precision calculations, 3 to 4 times at single precision and 1.5 to twice as fast with integers. This A15 obtains 1.8 MIPS/MHz.
The app can be downloaded from
www.roylongbottom.org.uk/MemSpeed.apk.
The program code used is the same as
Linux Multithreading Benchmarks.htm
and (nearly)
MemSpd2k Results.htm.
Results on an Intel Atom, for a single thread, using the multithreading benchmark, are shown below. On a per MHz basis, the Cortex-A9 performs well using L1 cache, comapared with the Atom but not always so with RAM based data.
Except for certain RAM tests, the Cortex-A15's performance is significantly better than the Atom.
T1, ARM 926EJ 800 MHz, Android 2.2, DDR2 RAM Android MemSpeed Benchmark 17-Feb-2012 17.47 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 60 44 600 93 76 694 32 46 38 146 60 56 146 64 48 37 154 66 54 144 128 48 36 155 65 53 144 256 48 36 153 65 56 135 512 48 38 153 65 57 142 1024 47 37 153 65 57 142 4096 47 37 152 67 55 142 16384 47 37 152 70 63 138 65536 44 37 153 106 92 142 Total Elapsed Time 93.5 seconds Maximum SP MFLOPS 11 Integer MIPS 468 T2, ARM Cortex-A9 800 MHz, Android 2.3.4 DDR2 RAM Android MemSpeed Benchmark 17-Feb-2012 17.41 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 1002 533 1574 1742 812 1639 32 1042 530 1533 1717 701 1751 64 994 461 984 1144 644 942 128 656 396 691 696 511 673 256 269 259 273 271 255 280 512 249 246 244 256 244 247 1024 249 249 244 240 253 244 4096 246 244 247 246 242 245 16384 253 236 252 254 241 246 65536 254 241 253 250 252 241 Total Elapsed Time 19.4 seconds Maximum SP MFLOPS 133 Integer MIPS 1228 T4, ARM Cortex-A9 1500 MHz, Android 4.0.3 DDR3 RAM Measured 1200 MHz Android MemSpeed Benchmark 11-May-2012 17.00 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 1631 834 2425 2700 1353 2799 32 1585 823 1863 2105 1185 2060 64 1265 724 1266 1532 982 1369 128 1311 715 1243 1480 963 1318 256 1229 697 1209 1295 938 1284 512 1044 579 1004 1203 680 1009 1024 473 405 474 482 430 474 4096 413 387 419 408 389 424 16384 410 386 423 408 382 422 65536 405 371 419 397 384 418 Total Elapsed Time 12.9 seconds Maximum SP MFLOPS 209 Integer MIPS 1892 T7, ARM Cortex-A9 1300 MHz, Android 4.1.2, 1 GB DDR3 RAM Measured 1200 MHz Android MemSpeed Benchmark 17-Oct-2012 20.19 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 1735 888 2456 2726 1364 2818 32 1448 760 1474 1700 1039 1648 64 1318 719 1290 1468 952 1385 128 1279 715 1289 1443 944 1336 256 1268 714 1279 1435 943 1313 512 1158 691 1204 1321 892 1228 1024 729 553 735 772 632 742 4096 445 392 425 442 421 439 16384 435 390 428 435 412 431 65536 445 404 393 450 432 449 Total Elapsed Time 12.2 seconds Maximum SP MFLOPS 222 Integer MIPS 1916 T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8 Android MemSpeed Benchmark 1.1 05-Mar-2013 10.01 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 293 124 1376 481 241 1439 32 296 119 1389 482 230 1646 64 220 86 783 345 241 1301 128 288 122 1081 475 224 1288 256 233 106 462 315 197 513 512 188 98 256 247 168 276 1024 185 95 214 249 162 233 4096 183 98 228 248 163 236 16384 174 96 228 234 163 234 65536 183 98 206 243 155 214 Total Elapsed Time 29.8 seconds Maximum SP MFLOPS 31 Integer MIPS 1075 T9 ARM 926EJ 800 MHz, Android 2.2 Android MemSpeed Benchmark 1.1 09-jul-2013 22.59 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 52 36 510 61 67 579 32 41 30 129 52 48 129 64 35 33 133 54 47 125 128 41 25 126 58 47 124 256 43 31 134 53 49 119 512 43 35 154 65 56 144 1024 47 38 153 65 56 146 4096 48 38 153 67 58 144 16384 43 37 152 73 63 144 65536 47 37 152 106 92 146 Total Elapsed Time 102,2 seconds Maximum SP MFLOPS 11 Integer MIPS 398 T11 Samsung EXYNOS 5250 2000 MHz Cortex-A15, Android 4.2.2 Measured 1700 MHz Android MemSpeed Benchmark 1.1 09-Aug-2013 17.04 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 7296 4159 3513 9375 5453 6211 32 7253 4540 3882 7364 4873 4839 64 6902 4265 3878 7026 4373 4274 128 6735 4032 2480 4005 2797 3288 256 5859 3775 2192 4527 3263 3676 512 5795 3781 3568 6282 3819 3818 1024 2609 1757 1754 2607 1805 1825 4096 1614 1422 1471 1654 1342 1441 16384 1624 1412 1474 1642 1336 1443 65536 1617 1408 1479 1368 1321 1423 Total Elapsed Time 10.7 seconds Maximum SP MFLOPS 1135 Integer MIPS 3028 P6, Qualcomm S4 1500 MHz, Android 4.0.3, 1 GB DDR2 RAM Android MemSpeed Benchmark 07-Jun-2012 09.45 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 2564 1428 1600 3697 1947 1894 32 2003 1381 1006 2432 1489 1118 64 1864 1284 1011 2378 1448 834 128 1868 1289 1004 2343 1431 1110 256 1865 1288 1010 2379 1442 1117 512 1853 1274 1004 2372 1429 1115 1024 855 731 658 941 782 694 4096 674 604 553 731 642 556 16384 668 605 554 730 640 585 65536 672 602 557 728 639 590 Total Elapsed Time 10.6 seconds Maximum SP MFLOPS 357 Integer MIPS 1248 P8 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2 Android MemSpeed Benchmark 10-Jul-2012 22.10 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 3636 2162 2509 4782 3181 2796 32 3109 1900 1512 3823 2330 1725 64 2931 1792 1514 3744 2277 1717 128 2927 1809 1512 3747 2276 1723 256 2920 1817 1506 3732 2269 1716 512 2320 1581 1345 2753 1894 1497 1024 1101 934 859 1161 1000 884 4096 902 823 766 965 830 777 16384 923 818 754 957 829 774 65536 926 821 754 957 827 776 Total Elapsed Time 10.4 seconds Maximum SP MFLOPS 541 Integer MIPS 1957 P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2 Android MemSpeed Benchmark 25-Sep-2012 09.05 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 3048 2203 2559 5452 3168 2784 32 2823 1720 1504 3827 2328 1723 64 2662 1787 1505 3793 2269 1716 128 2654 1812 1511 3800 2235 1717 256 2812 1808 1505 3793 2280 1709 512 2343 1580 1336 2833 1875 1496 1024 1177 966 876 1245 1012 916 4096 802 785 730 910 779 750 16384 882 722 729 913 791 745 65536 873 732 722 906 645 744 Total Elapsed Time 10.8 seconds Maximum SP MFLOPS 550 Integer MIPS 1996 P11 ARM Cortex-A9 1.4 GHz, Android 4.0.4, DCDDR2 Android MemSpeed Benchmark 23-Dec-2012 15.16 Reading Speed in MBytes/Second Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m] KBytes Dble Sngl Int Dble Sngl Int 16 983 926 2849 3162 1578 3265 32 1825 911 1694 2084 949 1892 64 1810 894 1654 1999 1174 1659 128 1816 867 1599 1945 1168 1758 256 1813 870 1596 1931 1162 1765 512 1802 868 1570 1779 1098 1740 1024 1569 828 1474 1776 1110 1634 4096 1362 817 1105 1310 1066 1335 16384 1287 825 1304 1338 926 1319 65536 1319 824 1298 1294 1072 1284 Total Elapsed Time 12.0 seconds Maximum SP MFLOPS 231 Integer MIPS 2222 Atom 1666 MHz, DDR2 RAM 800 MHz, Linux 16 1892 943 1979 2759 1329 2813 64 1647 879 1690 2334 1269 2323 65535 1515 834 1517 2010 1208 1945 |
Some assumptions regarding memory and bus speeds are aired here, based on knowledge provided for mainstream PCs, Google searches and results below. Whereas PC memory bus width is 8 bytes (per channel), that for these ARM systems is 4 bytes or less, considerably reducing relative maximum memory data transfer speeds.
As with PCs, data is read in bursts and this is normally clear from BusSpeed results, from which maximum data transfer speeds can be estimated. Suggested burst size for System T1 is 8 words or 32 bytes with maximum speed of 29 x 8 or 232 MB/second. For T2 and T4, 16 byte bursts are suggested with maximum speed between 35 x 16 to 39 x 16 or 560 to 624 MB/second. One reason for not achieving this performance is startup delays (CAS Latency - number of bus clocks).
It seems to be extremely difficult to obtain details of bus speeds and channel/bus configurations for Android devices. T7 appears to have single channel, double data rate 1333 MHz RAM, where maximum speed would be 666.7 (clock MHz) x 2 (DDR) x 4 (32 bit wide bus) = 5.33 GB/second. Then P11, with dual channel, DDR 1066 MHz RAM, could produce 533 x 2 x 2 (channels) x 4 = 8.53 GB/second. Speed estimated from burst tests and real measurements are nowhere near these maximum speeds but can be much faster using the MultiThreading Benchmark version.
There are startup delays on transferring bursts of data, usually associated with the number of bus clocks under the heading of CAS Latency. With DDR, a one clock overhead can reduce data transfer rate by 33%. Measured maximum speed reading all data can also be much lower than that derived from burst reading tests, due to various internal processor delays. For examples see the AndI 2Reg and AndI 1Reg) in
BusSpd2K Memory Speed Results.
This benchmark is designed to identify reading data in bursts over buses. The program starts by reading a word (4 bytes) with an address increment of 32 words (128 bytes) before reading another word. The increment is reduced by half on successive tests, until all data is read. On reading data from RAM, 64 Byte bursts are typically used. Then, measured reading speed reduces from a maximum, when all data is read, to a minimum on using 16 word increments (64 bytes). Potential maximum speed can be estimated by multiplying this minimum value by 16. With this burst rate, measured speed at 32 word and 16 word increments are likely to be the same. Cache sizes are indicated by varying speed as memory use changes. Note, with smallest L1 cache demands, measured speed can be low due to overheads when reading little data.
The program C source code is as used for Linux, See BusSpd2K Results.htm. This has unrolled loops with up to 64 AND statements (& array[i ] to & array[i+63]). The Linux compiler for Intel CPUs translates this into 64 assembly instructions ANDing data from indexed memory locations. In this case, Integer MIPS approximately equals MB/second divided by 4. The Android NDK compiler generates 133 assembler type instructions, including 64 loads and 64 ANDs, where MIPS equates to MB/second divided by 1.92 (64 x 4 / 133) - twice as many instructions as Intel. Maximum MIPS and MIPS/MHz details have been added to the results below.
With data from L1 cache, tablets T4 and T7 again produce lower performance than might be expected, compared with CPU MHz with T6 better, compared with P11. The Qualcomm Snapdragon results are also on the low side, and it appears to have burst reading from L1 cache, with much lower data transfer speeds with the highest incremented addressing. As with MemSpeed, the upgraded Cortex-A9 CPU in P11 provides significant performance gains using L2 cache and RAM. Unlike using L1 cache, the Qualcomm CPU provides superior performance at high address increments.
August 2013 - T11, with the EXYNOS running at 1700 MHz, produces the best integer performance so far, or a maximum of 3224 MIPS or 1.9 MIPS per MHz. This can be compared with P11 Cortex-A9 at 1400 MHz, that reaches 2205 MIPS or 1.6 MIPS per MHz. T11’s L2 cache is even more efficient at twice the speed of P11, after adjusting for the same CPU MHz.
The original benchmark application can be downloaded from
www.roylongbottom.org.uk/BusSpeed.apk.
and the Android 4 version from
www.roylongbottom.org.uk/BusSpeedv7.apk.
RandMem benchmark carries out four tests at increasing data sizes to produce data transfer speeds in MBytes Per Second from caches and memory. Serial and random address selections are employed, using the same program structure, with read and read/write tests using 32 bit integers. The main purpose is to demonstrate how much slower performance can be through using random access. Here, speed can be considerably influenced by reading and writing in bursts, where much of the data is not used, and by the size of preceding caches.
The benchmark uses the first four tests described in RandMem Results.htm and can be downloaded from www.roylongbottom.org.uk/RandMem.apk. The program structure is as follows, with array xi indexing via sequential or random numbers stored in the array.
Read - toti = toti & xi[xi[i+0]] | xi[xi[i+2] & xi[xi[i+4]] | xi[xi[i+4]] and &| to i+30 Read/write - xi[xi[i+2]] = xi[xi[i+0]]; xi[xi[i+6]] = xi[xi[i+4]]; repeated to i+30 and i+28
The results below show that random access performance is approximately the same as BusSpeed with address increments of 32 words, the burst reading effect. This program is again based on indexed memory addressing where the older technology CPU can be faster than than the System T2. This might be due to poor implementation of the memory bus interface on this tablet, as noted on PC tests. Atom results are provided, again showing better relative performance, particularly when using data from RAM. As with BusSpeed, and not noticed so far on the other benchmarks, measured speeds using L1 cache are sometimes slow to start with.
Relative performance of Cortex CPUs is similar to the other memory tests. The Qualcomm Snapdragon performs very well on random access to L2 cache and RAM, repeating the effects of faster burst reading speed seen in BusSpeed.
August 2013 - Cortex-A15 based T11 again come out fastest at this time. Best comparative performance is for data using L2 cache, particularly with serial reading. where RAM speed comparisons are also good.
System T1, ARM 926EJ 800 MHz, Android 2.2 Android RandMem Benchmark 20-Feb-2012 16.51 MBytes/Second transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 841 1119 666 955 32 222 147 83 62 64 145 169 56 53 128 198 181 48 57 256 191 178 44 58 512 196 180 27 32 1024 189 180 22 26 4096 193 181 19 23 16384 195 177 19 22 65536 186 166 19 22 Total Elapsed Time 49.0 seconds System T2, ARM Cortex-A9 800 MHz, Android 2.3.4 Android RandMem Benchmark 20-Feb-2012 16.45 MBytes/Second transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 1777 1879 1669 1809 32 1359 1394 1185 1505 64 799 861 621 755 128 394 202 295 333 256 147 146 92 104 512 133 136 71 42 1024 125 125 53 62 4096 129 98 41 53 16384 128 113 42 45 65536 121 115 30 32 Total Elapsed Time 15.7 seconds System T4, ARM Cortex-A9 1500 MHz, Android 4.0.3 Measured 1200 MHz Android RandMem Benchmark 11-May-2012 17.19 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 2777 3014 2671 3021 L1 32 2254 2490 2062 2561 64 872 1109 875 998 L2 128 797 870 674 721 256 807 932 528 560 512 543 465 186 182 1024 388 241 78 83 RAM 4096 367 229 56 48 16384 366 229 48 45 65536 335 228 41 38 Total Elapsed Time 13.2 seconds T7, ARM Cortex-A9 1300 MHz, Android 4.1.2, Measured 1200 MHz Android RandMem Benchmark 20-Oct-2012 11.14 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 2788 3041 2795 3041 L1 32 2769 3011 2767 3020 64 1027 1038 839 911 L2 128 916 918 616 649 256 904 905 514 538 512 899 907 475 499 1024 712 699 345 354 4096 323 284 92 88 RAM 16384 316 282 73 70 65536 314 281 65 62 Total Elapsed Time 10.9 seconds T6, ARM Cortex-A9 1600 MHz, Android 4.0.3, DDR3 RAM Android RandMem Benchmark 26-Aug-2012 13.58 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 3925 4257 3881 4275 L1 32 3867 4204 3864 3998 64 1276 1284 1042 1182 L2 128 1126 1133 775 844 256 1118 1121 641 706 512 1107 1113 584 655 1024 750 715 352 366 4096 362 314 103 97 RAM 16384 337 317 84 79 65536 369 317 75 71 Total Elapsed Time 10.3 seconds T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8 Android RandMem Benchmark 1.1 05-Mar-2013 10.03 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 2032 2787 2057 2802 L1 32 2014 2736 1972 2668 64 458 309 92 141 L2 128 423 316 74 121 256 304 204 39 58 RAM 512 270 201 29 36 1024 267 192 27 39 4096 258 197 23 35 16384 247 206 22 34 65536 254 206 19 28 Total Elapsed Time 20.7 seconds T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2 Measured 1.7 GHz Android RandMem Benchmark 1.1 13-Aug-2013 17.29 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 2881 2478 3388 3650 32 4301 2968 3197 3249 64 3669 2511 2201 2249 128 3566 2560 1571 1566 256 3557 2461 1334 1256 512 3524 2547 1136 1098 1024 1933 1144 534 513 4096 1993 1064 184 173 16384 1970 1086 141 144 65536 1973 1117 106 104 Total Elapsed Time 9.1 seconds P11, ARM Cortex-A9 1.4 GHz, Android 4.0.4 Android RandMem Benchmark 23-Dec-2012 15.18 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 3253 3542 3255 3438 L1 32 2626 2794 2511 2945 64 1453 1471 1298 1467 L2 128 1298 1302 1030 1095 256 1279 1289 819 826 512 1054 1075 237 245 1024 1155 989 150 146 4096 1101 919 107 106 RAM 16384 1061 911 91 90 65536 1048 919 73 77 Total Elapsed Time 10.7 seconds P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2 Android RandMem Benchmark 25-Sep-2012 09.02 MBytes/Second Transferring 4 Byte Words Memory Serial....... Random....... KBytes Read Rd/Wrt Read Rd/Wrt 16 1878 3732 2564 3081 L1 32 1545 1796 1258 1487 L2 64 1472 1797 1030 1205 128 1502 1769 869 1084 256 1548 1786 795 938 512 1323 1264 604 798 1024 745 697 230 268 4096 425 457 149 145 RAM 16384 481 458 120 130 65536 501 458 100 106 Total Elapsed Time 10.2 seconds Atom 1666 MHz, DDR2 RAM 800 MHz, Linux 16 3976 5132 4100 5134 64 3086 3215 1042 1349 65536 2708 1290 49 74 |
Primarily to measuring performance of SD cards and internal drives, DriveSpeed carries out four tests.
Test 1 - Write and read three 8 and 16 MB; Results given in MBytes/second
Test 2 - Write 8 MB, read can be cached in RAM; Results given in MBytes/second
Test 3 - Random write and read 1 KB from 4 to 16 MB; Results are Average time in milliseconds
Test 4 - Write and read 200 files 4 KB to 16 KB; Results in MB/sec, msecs/file and delete seconds.
DriveSpeed was produced for early Android systems that had an internal drive and an external SD card. These were identified by specific programming functions and executed via two buttons RunI and RunS. The general form was that RunS used direct I/O, avoiding data being cached in RAM. but RunI used cached data. A More button was provided for the latter with choices of Don’t Delete and/or Read Only, allowing reading speed to be measured after rebooting. This is still available but has an added display to identify drive capacity and free space, helping to identify the drive/card used. The directory path for the device used is also shown.
With later versions of Android or system hardware, the internal drive could have the largest part operating as an SD drive and the remainder as a cached drive. The directory path used was also found to vary on different systems. DriveSpeed2 starts with an input request to type in the path. This can normally be found via a FileBrowser app. Then there are Run and Restart buttons, the latter to correct a false entry or to select a different drive. There is also a Save button to Email results (to me or/and whoever). These new procedures also allowed USB connected devices to be selected (in some cases).
The benchmark can be downloaded from the links
DriveSpeed
and
DriveSpeed2.
Below are examples of results. These include the usual configuration details (see above). Drive capacity and paths used for later example results are also provided.
|
The benchmark is a subset of a version produced for PCs, the Windows version drivespeed32.exe, found in drivespeed32.zip, with drivespeed32 and drivespeed64, Linux varieties, from this tar.gz file. The execution files can be copied to to Android drives and executed on a PC via a USB connection. Details and results on a range of systems are provided in linux_disk_usb_lan_benchmarks.htm. Here, device "Sig" id the same USB stick as USBS1 below and is extremely slow on writing small files and deleting them via Windows. This is a Windows problem associated with too frequent updates of the File Allocation Table, under FAT formatting.
Large Files - The speed of large files on internal drives has been slow, compared with PC hard drives, but that on tablet T11 shows an improvement, where reading speeds can be 50 MB/second. However, SD4, the super fast SD card does not perform well as an external card. T11 also has a USB 3 connector, where reading speed can sometimes be similar to the internal drive but, in both cases, writing speed is disappointing.
Small Files - In the case of Sig, mentioned above, minimum time to write small files via Windows was around 300 milliseconds, but more modern memory can produce similar speeds to Android. For example, SD4 minimum time is around 17 milliseconds using the Windows version (USB2). This is still excessive as hard drives can have a minimum of 0.5 milliseconds.
Cached Files - These are where Android is allowed to keep a copy of the data in main memory. Here, writing speeds can vary considerably, from just writing to memory, to saving to the drive. Reading performance can reflect memory speed.
Random Access - As shown in
Linux Results,
random writing speeds can be subject to extremely wide variations on flash drives, and random reading times can be less than on disk drives that are subject to rotational delays. Disk random reading speeds can be faster on small files, as the data is cached in a buffer.
|
Some of these benchmarks produce poor performance, influenced by Power Saving options and short running time. For versions that run for extended periods see Android Long MP Benchmarks.htm.
MP-MFLOPS - measures floating point speed on data from caches and RAM. The arithmetic operations executed are of the form x[i] = (x[i] + a) * b - (x[i] + c) * d + (x[i] + e) * f with 2 and 32 operations per input data word. Data sizes are also limited to three to use L1 cache, L2 cache and RAM at 12.8, 128 and 12800 KB (3200, 32000 and 3200000 single precision floating point words). The program is run using 1, 2, 4 and 8 threads.
MP-Whetstone - Multiple threads each run the eight test functions at the same time, but with some dedicated variables. Measured speed is based on the last thread to finish, with Mutex functions, used to avoid the updating conflict by only allowing one thread at a time to access common data. Again performance is generally proportional to the number of cores used. Floating point speeds and the overall rating, using one thread, are similar to the single CPU version, but integer calculations are slower for some reason.
MP-Dhrystone - This runs multiple copies of the whole program at the same time. Dedicated data arrays are used for each thread but there are numerous other variables that are shared. The latter reduces performance gains via multiple threads (example - 2 threads 1.8 x speed). Single thread results are also slightly slower than the normal benchmark.
MP-BusSpeed - This runs integer read only tests using caches and RAM, each thread accessing the same data sequentially. Performance gains, using L1 cache, can be proportional to the number of cores, but not quite so using L2. The program is designed to produce maximum throughput over buses and demonstrates the fastest RAM speeds using multiple cores.
MP-RandMem - The benchmark has cache and RAM read only and read/write tests using sequential and random access, each thread accessing the same data but starting at different points. It uses the Mutex functions as in Whetstone above. Performance characteristics tend to be constant on a particular system but can be unpredictable, like slower speed using a higher number of threads. On a dual core CPU, there were reasonable gains (1.7x) on serial reading but none elsewhere. A quad core processor showed no gains at all, resulting in certain tests being slower than the dual core system.
Some of the benchmarks have been converted to use NEON Single Instruction Multiple Data (SIMD) instructions, using special ARM intrinsic functions. In this case, operating on four 32 bit numbers at the same time. These SIMD instructions are equivalent to Intel SSE and AMD 3DNow instructions. For details and results see www.roylongbottom.org.uk/Android NEON Benchmarks.htm.
NeonSpeed - This benchmark carries out the same calculations as MemSpeed single precision floating point and integer tests, using caches and RAM. MemSpeed normal calculations are carried out besides the same ones using NEON functions. The latter can be more than three times faster.
NEON MP MFLOPS - This is the same as MP-MFLOPS benchmark above, except, in this case, the operational sequences are generated by NEON Intrinsic Functions.
NEON Linpack - This is the same as the single precision version of the Linpack 100 Benchmark, described above, except NEON intrisic functions are used for the key calculations.
NEON Linpack MP - This version uses mainly the same C programming code as the single precision floating point NEON compilation above. It is run run on 100x100, 500x500 and 1000x1000 matrices using 0, 1, 2 and 4 separate threads. The 0 thread procedures are identical to above. The initial 100x100 Linpack benchmark is only of use for measuring performance of single processor systems. The one for shared memory multiple processor systems is a 1000x1000 variety. The programming code for this is the same as 100x100, except users are allowed to use their own linear equation solver. Unlike the NEON MP MFLOPS benchmark, that carries out the same multiply/add calculations, this program can run much slower using multiple threads. This is due to the overhead of creating and closing threads too frequently, relative to calculation time.
JavaOpenGL1 -
This benchmark does not rely on complex visual scenes or mathematical functions. The objective being to generate moderate to excessive loading via multiple simple objects. It uses all Java code, with OpenGL ES GL10 statements, to measure graphics performance in Frames Per Second (FPS). Four tests draw a background of 50 cubes first as wireframes then colour shaded. The third test views the cubes in and out of a tunnel with slotted sides and roof, also containing rotating plates. The last test adds textures to the cubes and plates. The 50 cubes are redrawn 15, 30 and 60 times, with randomised positions, colours rotational settings. With 6 x 2 triangles per cube, minimum triangles per frame for the three sets of tests are 9000, 18000 and 36000.
Details and results can be found in
Android Graphics Benchmarks.
The procedure to use is to load a benchmark then load CPU_MHz, forcing the benchmark into the background. Start the CPU_MHz program, switch the benchmark into foreground and start that. The method for switching apps is not the same on all devices, so you will have to look it up (latest is to press multi-task bottom on-screen button).
Following shows results, measuring MHz whilst running MemSpeed Benchmark, whose results were proportional to MHz.
For comparative benchmarking, running continuously at maximum MHz is desirable.
################################################## T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2 Energy Saving Off MemSpeed Total Elapsed Time 10.9 seconds Android Java CPU MHz 13-Aug-2013 16:55:50 0.00 1000 1.02 1000 2.08 1000 3.11 1000 4.16 1000 5.18 1000 6.24 1000 7.29 1000 8.32 1700 9.34 1200 10.35 1700 11.36 1700 12.38 1700 13.40 1700 14.42 1700 15.45 1700 16.48 1700 17.50 1700 18.54 1000 19.59 1000 20.64 1000 21.67 1000 22.72 1000 23.76 1000 24.82 1000 25.87 1000 26.93 1000 27.98 1000 29.04 1000 30.08 1000 Running Finished 13-Aug-2013 16:56:22 Energy Saving On MemSpeed Total Elapsed Time 11.9 seconds Android Java CPU MHz 14-Aug-2013 11:12:55 0.00 1000 1.02 1000 2.05 1000 3.08 1000 4.11 1000 5.14 1000 6.20 1000 7.23 1000 8.24 1000 9.26 1000 10.28 1000 11.30 1000 12.32 1000 13.34 1000 14.36 1000 15.40 1000 16.43 1000 17.46 1000 18.49 1000 19.52 1000 20.56 1000 21.59 1000 22.62 1000 23.65 200 24.72 1000 25.76 1000 26.80 1000 27.83 1000 28.89 1000 29.92 1000 Running Finished 14-Aug-2013 11:13:26 ################################################## T7 ARM Cortex-A9 1300 MHz, Android 4.1.2 Battery Power MemSpeed Total Elapsed Time 11.7 seconds Android Java CPU MHz 14-Aug-2013 09:11:23 0.00 1000 1.03 475 2.06 760 3.09 1300 4.13 1300 5.17 1300 6.31 640 7.34 1200 8.36 1200 9.37 1200 10.39 1200 11.40 1200 12.42 1200 13.43 1200 14.45 1200 15.47 1200 16.49 1200 17.51 1200 18.53 1200 19.57 1000 20.60 760 21.62 1200 22.66 760 23.68 475 24.71 1300 25.74 475 26.78 475 27.82 475 28.85 475 29.89 475 Running Finished 14-Aug-2013 09:11:54 ################################################## T4 ARM Cortex-A9 1500 MHz, Android 4.0.3 CPU Development Performance Setting MemSpeed Total Elapsed Time 13.0 seconds Android Java CPU MHz 14-Aug-2013 16:26:27 0.00 1200 1.02 1200 2.04 1200 3.06 1200 4.07 1200 5.09 1200 6.12 1200 7.13 1200 8.15 1200 9.17 1200 10.18 1200 11.20 1200 12.22 1200 13.25 1200 14.27 1200 15.30 1200 16.32 1200 17.34 1200 18.37 1200 19.40 1200 20.44 1200 21.46 1200 22.47 1200 23.49 1200 24.51 1200 25.52 1200 26.54 1200 27.56 1200 28.61 1200 29.63 1200 Running Finished 14-Aug-2013 16:26:58 CPU Development Normal MHz Setting MemSpeed Total Elapsed Time 13.6 seconds Android Java CPU MHz 14-Aug-2013 16:21:44 0.01 288 1.08 192 2.16 192 3.25 96 4.42 192 5.66 288 6.71 288 7.84 192 8.93 384 9.97 864 10.99 1200 12.01 1200 13.03 1200 14.05 1200 15.07 1200 16.10 1200 17.12 1200 18.14 1200 19.17 1200 20.20 1200 21.22 1200 22.24 1104 23.26 720 24.29 336 25.34 144 26.46 144 27.57 144 28.69 144 29.81 144 30.92 144 Running Finished 14-Aug-2013 16:22:16 |
Three of the tests provided, load and display image files, each of around one million bytes, but producing different numbers of pixels to display. Format of these files are uncompressed BMP, compressed GIF and compressed JPG. A further test loads 400 different GIF icons, each sized approximately 70 Bytes. These functions, using Java script, are copied from another HTML file, for use here, as they have been found to work on Android based devices, but in some strange ways. That HTML document also runs the Whetstone benchmark via Java Applets, but these do not run using Android.
When images are loaded, they can be saved in the browser’s cache on the local device disk. On resubmitting the image page address, or selecting Refresh, the images are likely to be loaded from the cache at high speed. This is generally avoided by loading via a .htm file, renamed as .php, with the time added to the file name, for example using
<img src="gif1m.gif?<? echo time(); ?>">.
Note that the measured time is less than the actual time taken, typically by up to 1.5 seconds, but can be closer on selecting Refresh. Below are results, based on at least three measurements on the same broadband connection, where maximum speed is normally around 10 Mbps. So, it is likely that minimum loading of the 1 MB files will be greater than one second. For reference, results using Windows and Linux are also provided. These showed that Linux and Firefox was generally faster than Windows with Internet Explorer but Firefox did not help via Windows.
Initial loading times on Android tablet T2 were really slow, using the default browser. Opera, with high speed claims, was installed but only managed to speed up loading times of the small GIF files. T1 tablet, with the older CPU, provided some faster results than PCs with Windows, but failed to display the 1 MB GIF file.
A broadband speed tester confirmed the slow T2 speed at 0.6 Mbps whilst a Linux desktop PC produced 8.5 Mbps.
Loading Time Seconds MHz OS 1 MB BMP 1 MB GIF 1 MB JPG 400 GIF Wireless Tablet T1 ARM 926EJ 800 Android 2.2 2.5-2.8 2.5-2.6# 2.3-2.7 6.5-7.4 Tablet T2 ARM v7-A9 800 Android 2.3.4 13.8-14.4 12.9-14.3 13.4-14.8 11.4-12.3 Tablet T2 ARM v7-A9 800 Andr 2.3.4 OP 13.5-14.3 13.0-14.8 13.2-13.7 5.5-6.0 Tablet T4 ARM v7-A9 1500 Android 4.0.3 2.0-2.3 2.1-2.5 2.0-2.4 3.9-5.2 Netbook Atom 1666 WinXP IE 5.5-5.8 2.5-4.1 2.6-3.2 7.4-8.0* Netbook Atom 1666 Abuntu FF 1.1-2.3 1.1-2.2 1.2-2.6 4.6-6.6 Laptop Core 2 1833 Win Vista IE 3.3-3.7 3.2-3.4 3.4-3.6 20.7-22.6 Laptop Core 2 1833 Abuntu FF 1.4-2.4 1.3-1.3 1.2-1.8 4.9-5.2 Wired Desktop 1 Core 2 1600 Abuntu FF 2.2-2.7 1.8-2.9 1.8-1.9 4.6-4.6 Desktop 1 Core 2 2400 Abuntu FF 1.9-2.3 1.1-1.4 1.2-1.4 4.6-4.6 Desktop 2 Phenom 3000 Win 7 IE 2.5-4.3 2.4-3.0 2.4-2.5 4.7-4.8 Desktop 2 Phenom 3000 Win 7 FF 2.4-2.7 2.5-3.0 3.5-2.7 5.3-6.1 Desktop 2 Phenom 3000 Win 7 GC 2.3-2.7 2.5-3.0 2.5-2.6 5.1-6.1 |
BlueStacks is an Android App Player that runs under Windows, downloadable (free October 2012) from www.bluestacks.com. The package allocates an icon to any .apk files on a PC. A right click on these gives an option to Open with BlueStacks APP Installer. A download from Internet saves the files on an imaginary SD card and they can be installed from there.
I installed the app on a 64-Bit Windows 7 PC with a 3 GHz quad core Phenom CPU and a 1.83 GHz Core 2 Duo based laptop under 32-Bit Windows Vista. It failed to install via 64-Bit Vista (needed unselectable Administrator approval) and Windows XP (needed something from SP3).
The Systems Used are identified below as BS1 and BS2 and some results are included above. Typically, NDK pre-compiled C/C++ benchmark code, using BlueStacks on a 3 GHz PC, runs at 5% of the speed of Windows versions or 10% of a 1.5 GHz Cortex-A9 tablet CPU. On the other hand, Java benchmarks can run at the same speed as the 1.5 GHz tablet and
much faster speeds can be obtained using RAM sized data - see
BusSpeed Benchmark above.
I had a go at installing Android on a PC to run some of my new benchmarks. First attempt was to download the ISO for an Android 4.0 variety, but that did not work. Second was generic_x86-20120611.iso (Android 2.2.1, Linux 2.6.35.7). This was burnt to a DVD, tested as live then installed on a USB stick (on a laptop using a Core 2 Duo with hard disk removed). The USB stick booted with Internet accessible via a LAN but WiFi would not connect. Keyboard worked OK, along with mouse left, centre and right button functions. I then found that I could not download my Java Apps. With a bit of luck I found that this was because I had opted to install on the existing drive FAT format, where saving is inhibited.
Next I opted for Ext3 formatting and, before restarting, I found that I could download and run my Java Apps, set up Email and post the results. Then I found that the USB stick would not boot. After several goes at pre-formatting and installing (takes little time), I found that it booted on two desktops (Core 2 DUO and Phenom) and on my Atom based Netbook but not on the Core 2 laptop.
The benchmarks run on these systems were Java Whetstone and Linpack benchmarks, but they are relatively slow, probably due to an inefficient Java Runtime Environment. Details are included above in Java Whetstone Benchmark Results and Java Linpack Results (see And x86).
Using the same programming functions, system information obtained is different running under Android x86. Some details are provided below.
Atom Android Build Version 2.2.1 bogomips : 3406.65 address sizes : 32 bits physical, 48 bits virtual processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 28 model name : Intel(R) Atom(TM) CPU N455 @ 1.66GHz stepping : 10 cpu MHz : 1667.000 cache size : 512 KB cpu cores : 1 Linux version 2.6.35.7-android-x86+ (root@afro) (gcc version 4.3.2 (Debian 4.3.2-1.1) ) #1 SMP PREEMPT Sun Feb 20 00:23:02 CET 2011 Core 2 Duo Android Build Version 2.2.1 bogomips : 4779.78 address sizes : 36 bits physical, 48 bits virtual processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 CPU 6600 @ 2.40GHz stepping : 6 cpu MHz : 2394.000 cache size : 4096 KB cpu cores : 2 Linux version 2.6.35.7-android-x86+ (root@afro) (gcc version 4.3.2 (Debian 4.3.2-1.1) ) #1 SMP PREEMPT Sun Feb 20 00:23:02 CET 2011 |
T1 Device TTFone M013S 10.1 inch tablet, 300-800 MHz VIA 8650 Screen pixels w x h 600 x 1024 Android Build Version 2.2 Processor : ARM926EJ-S rev 5 (v5l) BogoMIPS : 797.97 Features : swp half thumb fastmult edsp java CPU part : 0x926 Linux version 2.6.32.9 T2 Device WayTeq xTAB-70 7 inch tablet, 800 MHz Cortex-A9 Screen pixels w x h 600 x 800 Android Build Version 2.3.4 Processor : ARMv7 Processor rev 1 (v7l) BogoMIPS : 2035.71 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU part : 0xc09 - Cortex-A9 Linux version 2.6.34 T3 Device Samsung P7500 Screen pixels w x h 1280 x 752 Android Build Version 3.2 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 1998.84 processor : 1 BogoMIPS : 1998.84 Features : swp half thumb fastmult vfp edsp vfpv3 vfpv3d16 CPU part : 0xc09 - Cortex-A9 Linux version 2.6.36.3 T4 Device Miumiu w17 Pro 7 inch tablet, dual 1500 MHz Cortex-A9 Screen pixels w x h 600 x 976 Android Build Version 4.0.3 - Ice Cream Sandwich Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 2393.70 processor : 1 BogoMIPS : 2393.70 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU part : 0xc09 - Cortex-A9 Hardware : Amlogic Meson6 g04 customer platform Linux version 3.0.8 T5 Device Ainol Novo 7 Paladin Tablet, 1 GHz MIPS CPU, ARM emulation Screen pixels w x h 480 x 800 Android Build Version 4.0.1 system type : JZ4770 processor : MIPS-compatible processor JZ4770 cpu model : Ingenic Xburst BogoMIPS : 1005.97 Features : fpu mxu dsp lowpower CPU implementer : Ingenic CPU architecture : MIPS Hardware : npm702 Linux version 2.6.32.9 T6 Device Asus Transformer TF700 Screen pixels w x h 1920 x 1128 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 9 (v7l) processor : 0 BogoMIPS : 1993.93 processor : 1 BogoMIPS : 1993.93 processor : 2 BogoMIPS : 1993.93 processor : 3 BogoMIPS : 1993.93 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x2 CPU part : 0xc09 - Cortex-A9 CPU revision : 9 Hardware : cardhu - nVidia Tegra 3 Linux version 2.6.39.4 T7 Device Google Nexus 7 quad core CPU 1.3, GHz 1.2 GHz > 1 core RAM 1 GB DDR3L-1333 Bandwidth 5.3 GB/sec Screen pixels w x h 1280 x 736 MHz Twelve-core Nvidia GeForce ULP graphics 416 MHz Android Build Version 4.1.2 Processor : ARMv7 Processor rev 9 (v7l) processor : 0 BogoMIPS : 1993.93 processor : 1 BogoMIPS : 1993.93 processor : 2 BogoMIPS : 1993.93 processor : 3 BogoMIPS : 1993.93 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x2 CPU part : 0xc09 - Cortex-A9 CPU revision : 9 Hardware : grouper - nVidia Tegra 3 T30L Revision : 0000 Linux version 3.1.10 T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8 Internal Drive MB 1007 Free 917 SD Card MB 5455 Free 4575 Screen pixels w x h 800 x 432 Android Build Version 4.0.4 Processor : ARMv7 Processor rev 2 (v7l) BogoMIPS : 1001.88 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x3 CPU part : 0xc08 CPU revision : 2 Hardware : sun5i Revision : 0000 Linux version 3.0.8 T9 Device WM8650 800 MHz Screen pixels w x h 800 x 480 Android Build Version 2.2 Processor : ARM926EJ-S rev 5 (v5l) BogoMIPS : 797.97 Features : swp half thumb fastmult edsp java CPU implementer : 0x41 CPU architecture: 5TEJ CPU variant : 0x0 CPU part : 0x926 Hardware : WMT Linux version 2.6.32.9 T11 Voyo A15, Samsung EXYNOS 5250 Dual core 2.0 GHz Cortex-A15, Mali-T604 GPU, 2 GB DDR3-1600 RAM, dual channel, 12.8 GB/s Screen pixels w x h 1920 x 1032 Android Build Version 4.2.2 - Jelly Bean Processor : ARMv7 Processor rev 4 (v7l) processor : 0 BogoMIPS : 992.87 processor : 1 BogoMIPS : 997.78 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x0 CPU part : 0xc0f CPU revision : 4 Hardware : SMDK5250 Linux version 3.4.35Ut T12 Samsung GaIaxy Note 2, Quad core 1.6 GHz Cortex-A9 Screen pixels w x h 720 x 1280 Android Build Version 4.1.2 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 1592.52 processor : 2 BogoMIPS : 2189.72 processor : 3 BogoMIPS : 2189.72 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x3 CPU part : 0xc09 CPU revision : 0 Chip revision : 0020 Hardware : SMDK4x12 Revision : 000b Linux version 3.0.31 T13 Samsung Galaxy Note 1 Dual Core 1.4 GHz Cortex-A9 Screen pixels w x h 800 x 1280 Android Build Version 4.1.2 Processor : ARMv7 Processor rev 1 (v7l) processor : 0 BogoMIPS : 1592.52 processor : 1 BogoMIPS : 1990.65 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x2 CPU part : 0xc09 CPU revision : 1 Hardware : SMDK4210 Revision : 0008 Linux version 3.0.31 P1 Device Motorola Milestone 1 CyanogenMod 7 ROM overclocked Screen pixels w x h 854 x 480 Android Build Version 2.3.5 Processor : ARMv7 Processor rev 3 (v7l) BogoMIPS : 598.90 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU part : 0xc08 - Cortex-A8 Linux version 2.6.32.9 P2 Device Samsung Galaxy s Screen pixels w x h 480 x 800 Android Build Version 2.2 Processor : ARMv7 Processor rev 2 (v7l) BogoMIPS : 996.00 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU part : 0xc08 - Cortex-A8 Linux version 2.6.32.9 P3 Device Motorola Milestone 3 (XT860) Screen pixels w x h 960 x 540 Android Build Version 2.3.6 Processor : ARMv7 Processor rev 2 (v7l) processor : 0 - CPU 1 of 2 BogoMIPS : 598.90 - too low? Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3 CPU part : 0xc09 - Cortex-A9 Linux version 2.6.35.7 P4 Device Huawei u8800 - 800 MHz Scorpion CPU - Cortex-A8 Screen pixels w x h 480 x 800 Android Build Version 2.3.5 Processor : ARMv7 Processor rev 1 (v7l) BogoMIPS : 537.39 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU part : 0x00f Hardware : HUAWEI U8800 BOARD Linux version 2.6.35.7 P5 Device HTC One X - Quad Core Screen pixels w x h 720 x 1184 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 9 (v7l4 processor : 0 - CPU 1 of 4 BogoMIPS : 1993.93 Features : swp half thumb fastmult vfp edsp neon vfpv3 CPU part : 0xc09 - Cortex-A9 Hardware : endeavoru Linux version 2.6.39.4 P6 Qualcomm Snapdragon S4, 1500 MHz, 1 GB DDR2 RAM Device HTC One S Ville - Dual Core CPU MSM8260A? see P8 HTC One S MSM8960 Screen pixels w x h 540 x 888 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 13.53 processor : 1 BogoMIPS : 13.53 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x51 CPU architecture: 7 CPU variant : 0x1 CPU part : 0x04d CPU revision : 0 Hardware : ville Revision : 0080 Linux version 3.0.8- P7? Device not given. [Evidence suggests Marvell technology e.g. Marvell's Brownstone Development Platform and Marvell - PJ4Bv7 CPU with CPU implementer :0x56, architecture: 7, CPU part :0x584, rev 2] Screen pixels w x h 1280 x 752 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 831.32 processor : 1 BogoMIPS : 834.00 Features: swp half thumb fastmult vfp edsp iwmmxt thumbee neon vfpv3 CPU implementer : 0x56 CPU architecture: 7 CPU variant : 0x2 CPU part : 0x584 CPU revision : 0 Hardware : Brownstone2x Revision : 0000 Linux version 3.0.8, (Marvell GCC 201201) P8 Qualcomm Snapdragon S4, 1500 MHz, 1 GB dual channel RAM Device HTC One S - Dual Core CPU MSM8960 see P6 HTC One S MSM8260A? Screen pixels w x h 540 x 888 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 13.53 processor : 1 BogoMIPS : 13.53 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 CPU implementer : 0x51 CPU architecture: 7 CPU variant : 0x1 CPU part : 0x04d CPU revision : 0 Hardware : QCT MSM8960 CDP Revision : 0000 Linux version 3.0.8 P9 Device Samsung Galaxy s Captivate Screen pixels w x h 480 x 800 Android Build Version 2.3.5 Processor : ARMv7 Processor rev 2 (v7l) BogoMIPS : 996.00 Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3 CPU part : 0xc08 - Cortex-A8 Linux version 2.6.35.7 P10 Qualcomm Snapdragon S4, 1500 MHz, 1 GB dual channel RAM Device HTC One X - Dual Core CPU MSM8960 Screen pixels w x h 720 x 1184 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 13.53 processor : 1 BogoMIPS : 13.53 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x51 CPU architecture: 7 CPU variant : 0x1 CPU part : 0x04d CPU revision : 0 Hardware : elite Revision : 0080 Linux version 3.0.8 P11 Samsung Galaxy SIII, Quad Core 1.4 GHz Cortex-A9 Dual Channel DDR2 RAM Screen pixels w x h 720 x 1280 Android Build Version 4.0.4 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 1592.52 processor : 1 BogoMIPS : 2786.91 processor : 3 BogoMIPS : 398.13 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x3 CPU part : 0xc09 CPU revision : 0 Hardware : SMDK4x12 Revision : 000c Serial : 3b065f3d4df1bb2d Linux version 3.0.15 P13 Samsung Galaxy GT-I9100 SII Dual core 1.2 GHz Cortex-A9 Screen pixels w x h 480 x 800 Android Build Version 4.1.2 Processor : ARMv7 Processor rev 1 (v7l) processor : 0 BogoMIPS : 1592.52 processor : 1 BogoMIPS : 2388.78 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x2 CPU part : 0xc09 CPU revision : 1 Hardware : SHW-M250K Revision : 000a Linux version 3.0.31 P14 Hawaii? Dual Core Cortex-A9 Screen pixels w x h 540 x 888 Android Build Version 4.2.1 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 BogoMIPS : 2000.48 processor : 1 BogoMIPS : 2000.48 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x3 CPU part : 0xc09 CPU revision : 0 Hardware : hawaii Revision : 0000 Linux version 3.4.5 P16 LG G2X 512 MB Dual-channel RAM Dual-core Cortex-A9 1 GHz Screen pixels w x h 480 x 800 Android Build Version 2.3.4 Processor : ARMv7 Processor rev 0 (v7l) processor : 0 and 1 BogoMIPS : 1998.84 Features : swp half thumb fastmult vfp edsp vfpv3 vfpv3d16 CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x1 CPU part : 0xc09 CPU revision : 0 Hardware : Tegra 2 Development System Linux version 2.6.32 EP1 Device Emulator 3 GHz Phenom or 2.4 GHz Core 2 Screen pixels w x h 240 x 320 Android Build Version 2.2 Processor : ARM926EJ-S rev 5 (v5l) BogoMIPS : 522.64 Linux version 2.6.29 ET1 Device Emulator 3 GHz Phenom Screen pixels w x h 600 x 1024 Android Build Version 2.2 Processor : ARM926EJ-S rev 5 (v5l) BogoMIPS : 530.84 Linux version 2.6.29 ET2 Device Emulator 3 GHz Phenom or 2.4 GHz Core 2 Screen pixels w x h 600 x 1024 Android Build Version 4.0.3 Processor : ARMv7 Processor rev 0 (v7l) BogoMIPS : 527.56 Linux version 2.6.29 BS1 BlueStacks Emulator on 3 GHz Phenom Screen pixels w x h 1024 x 600 Android Build Version 2.3.4 processor : 0 vendor_id : AuthenticAMD cpu family : 16 model : 4 model name : AMD Phenom(tm) II X4 945 Processor stepping : 2 cpu MHz : 3013.000 cache size : 512 KB - - bogomips : 26686.25 Linux version 2.6.38 BS2 BlueStacks Emulator on 1.83 GHz Core 2 Duo Screen pixels w x h 1024 x 600 Android Build Version 2.3.4 processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Duo CPU T5550 @ 1.83GHz stepping : 13 cpu MHz : 1828.000 cache size : 2048 KB - - bogomips : 12294.55 Linux version 2.6.38 |