处理能力 - 移动设备与桌面 - 100倍的差异？

有没有人比较移动设备与PC的处理能力？我有一个非常简单的矩阵工作。用Java编码，我的旧电脑需要115ms才能完成工作。非常非常相同的功能需要17000毫秒。我非常震惊。我没有想到这款平板电脑会接近PC - 但我没有想到它的速度会降低150倍！处理能力 - 移动设备与桌面 - 100倍的差异？

有没有人有类似的经历？任何建议？如果我用C编写代码并使用Android NDK，它有帮助吗？

基准代码Java中：

package mainpackage; 

import java.util.Date; 



public class mainclass { 

    public static void main(String[] args){ 

     Date startD = new Date(); 
     double[][] testOut; 
     double[] v = {1,0,0}; 
     double t; 
     for (int i = 0; i < 100000; i++) { 
      t=Math.random(); 
      testOut=rot_mat(v, t); 
     } 
     Date endD = new Date(); 
     System.out.println("Time Taken ms: "+(-startD.getTime()+endD.getTime())); 


    } 

    public static double[][] rot_mat(double v[], double t) 
    { 
      double absolute; 
      double x[] = new double[3]; 
      double temp[][] = new double[3][3]; 
      double temp_2[][] = new double[3][3]; 
      double sum; 
      int i; 
      int k; 
      int j; 

      // Normalize the v matrix into k 
      absolute = abs_val_vec(v); 
      for (i = 0; i < 3; i++) 
      { 
       x[i] = v[i]/absolute; 
      } 


      // Create 3x3 matrix kx 
      double kx[][] = {{0, -x[2], x[1]}, 
           {x[2], 0, -x[0]}, 
           {-x[1], x[0], 0}}; 
      // Calculate output 
      // Calculate third term in output 
      for (i = 0; i < 3; i++) 
      { 
       for (j = 0; j < 3; j++) 
       { 
        sum = 0; 
        for (k = 0; k < 3; k++) 
        { 
         sum = sum + kx[i][k] * kx[k][j]; 
        } 
        temp[i][j] = (1-Math.cos(t))*sum; 
       } 
      } 
      // Calculate second term in output 
      for (i = 0; i < 3; i++) 
      { 
       for (k = 0; k < 3; k++) 
       { 
        temp_2[i][k] = Math.sin(t)*kx[i][k]; 
       } 
      } 


      // Calculate output 
      double[][] resOut = new double[3][3]; 
      for (i = 0; i < 3; i++) 
      { 
       for (k = 0; k < 3; k++) 
       { 
        resOut[i][k] = temp_2[i][k] + temp[i][k] + ((i==k)?1:0); 
       } 
      } 
     return resOut; 

    } 



    private static double abs_val_vec (double v[]) 
    { 
      double output; 

      output = Math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); 

      return output; 
    } 


}

来源

2014-02-09 Kasra

首先，我不会用'Date'做任何一种标杆... –

因子库中调出。你不想基准'随机'或触发函数。 –

@泰勒和迈克尔，我删除了trig函数和随机，我也将Date更改为System.currentTimeMillis（）。但它仍然慢了45倍。话虽如此，我不知道我是否明白为什么你说我不能使用trig函数？不要Android和Java对Math.sin使用相同的算法？ – Kasra

什么建议吗？

微基准只测量微基准的性能。而且，解释微观基准的唯一体面的方式是微观测量。因此，精明的程序员可以使用Traceview等工具更好地了解他们的时间。

我怀疑，如果你运行此通过Traceview，看着logcat中，你会发现你的时间被消耗在两个方面：

内存分配和垃圾收集。你的微基准测试通过〜3MB的堆空间咀嚼。在生产代码中，你永远不会那样做，至少如果你想保住你的工作。
浮点运算。根据您的平板电脑，您可能没有浮点协处理器，并且在CPU上执行浮点运算可能无法实现浮点协处理器，这非常缓慢。

它是否帮助，如果我写在C代码，并使用Android NDK？

那么，直到你在Traceview下剖析代码时，那将很难回答。例如，如果时间在sqrt()，cos()和sin()主要花费，已经是本机代码，你不会得到更快。

更重要的是，即使这条微基准可能与本机代码提高，所有做的是证明了这条微基准可能与本机代码提高。例如，这是C编译可能更快由于人工堆管理（malloc()和free()），而不是垃圾收集。但是，这更多的是对微观基准测试写得不好的说法，而不是对C的速度会有多快的说法，因为生产Java代码会比这更优化。

除了学习如何使用Traceview，我建议：

阅读the NDK documentation，因为它包括约当本地代码可能是有意义的信息。
上Renderscript Compute阅读起来。在某些设备上，使用Renderscript Compute可以将整数数值卸载到GPU上，从而大幅提升性能。这对浮点微指标没有帮助，但对于其他矩阵计算（例如图像处理），Renderscript Compute可能值得研究。当你比较非常不同的架构

来源

2014-02-09 23:34:34 CommonsWare

感谢您的注意。只是一个快速的一面说明，在分析后，我得到了~30％的三角函数，60％的“自我”，我相信这意味着我有简单的乘法... – Kasra

@Kasra：如果我正在解释你的“自我” ，那么这将是内存分配和内联操作，如浮点乘法。从垃圾收集的微基准中“偷走”的时间应该在Traceview中显示为暂停，在这种情况下似乎没有任何进展。这假设一个单核CPU;如果您使用多个内核，那么GC可能会在另一个内核上运行，并且对性能的影响将受到限制。 – CommonsWare

@Kasra：请注意，从理论上讲，JIT编译器应该将您的微基准转换为原生指令。我不知道有一个很好的方法来证实这一点。您可能希望对平板电脑中的CPU进行一些研究。如果它是ARMv7，它将有一个浮点协处理器。如果它是ARMv5，它不会。 – CommonsWare

处理独立电源并不代表一切。事实上，你很可能不会单独对计算架构进行基准测试。

基准测试的关键因素。当你处理一些需要考虑很多变量的事物时，会隔离你想测试的那个，并保持其他恒定并且最好相等。

在你的情况，对变量的一些例子，影响你的结果：

实际计算架构，这是一套复杂的变量本身（处理器的设计和实现，存储层次等）
操作系统
不同Java虚拟机实施不同的变量上面
附加层Dalvik暗示

来源

2014-02-09 23:34:47 webuster

在我的许多Android基准测试中，至少有8组PC和Android设备之间的比较。以下是我的Linpack基准测试结果（包括Java）的结果，它们显示Android比您的结果更好。其他结果（如Dhrystone）表明，在每MHz的基础上，ARM的CPU可以与Intel相匹配。

http://www.roylongbottom.org.uk/android%20benchmarks.htm

Linpack Benchmark Results 

System ARM MHz Android Linpackv5 Linpackv7 LinpackSP NEONLinpack LinpackJava 
See        MFLOPS  MFLOPS  MFLOPS  MFLOPS  MFLOPS 

    T1 926EJ 800  2.2  5.63  5.67  9.61  N/A  2.33 
    P4 v7-A8 800  2.3.5    80.18       28.34 @G 
    T2 v7-A9 800  2.3.4  10.56  101.39  129.05  255.77  33.36 
    P5 v7-A9 1500  4.0.3    171.39       50.87 @G 
    T4 v7-A9 1500a 4.0.3  16.86  155.52  204.61  382.46  56.89 
    T6 v7-A9 1600  4.0.3    196.47 
    T7 v7-A9 1300a 4.1.2  17.08  151.05  201.30  376.00  56.44 
    T9 926EJ 800  2.2  5.66 
    T11 v7-A15 2000b 4.2.2  28.82  459.17  803.04 1334.90  143.06 
    T12 v7-A9 1600  4.1.2    147.07 
    T14 v7-A9 1500  4.0.4    180.95 

    P11 v7-A9 1400  4.0.4  19.89  184.44  235.54  454.21  56.99 
    P10 QU-S4 1500  4.0.3    254.90 

Measured MHz a=1200, b=1700 


     Atom 1666  Linux    204.09  215.73    117.81 
     Atom 1666 Windows    183.22       118.70 
     Atom 1666 And x86             15.65 
     Core 2 2400  Linux    1288.00       901.00 
     Core 2 2400 Windows    1315.29       551.00 
     Core 2 2400 And x86             53.27 

System - T = Tablet, P = Phone, @G = GreenComputing, QU = Qualcomm CPU 
And 86 = Android x86

来源

2014-02-10 10:25:51

也许这是一个愚蠢的问题，但我可以问你在Linpack下列出的单位是什么？这是否意味着数字越小，计算速度越快？或者其他方式？ – Kasra

MFLOPS是每秒浮点运算的数百万次 - 用于浮点计算的标准性能度量 - 当然，最高值是最好的。 –

处理能力 - 移动设备与桌面 - 100倍的差异？

回答

相关问题