【问题标题】:Processing Power - Mobile Devices vs Desktop - 100x difference?处理能力 - 移动设备与台式机 - 100 倍的差异?
【发布时间】:2014-03-07 03:26:33
【问题描述】:

有没有人比较过移动设备与 PC 的处理能力?我有一个非常简单的矩阵工作。用 Java 编码,我的旧 PC 大约需要 115 毫秒才能完成工作。非常非常相同的功能需要 17000 毫秒。我非常震惊。我没想到平板电脑会接近 PC - 但我没想到它也慢了 ~ 150 倍!

有没有人有过类似的经历?有什么建议吗?如果我用 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;
    }


}

【问题讨论】:

  • 首先,我不会使用Date 进行任何类型的基准测试...
  • 因子库调用。您不想对 random 进行基准测试或触发函数。
  • @Tyler 和 Michael,我删除了三角函数和随机函数,我还将日期更改为 System.currentTimeMillis()。但它仍然慢了 45 倍。话虽如此,我不确定我是否理解你为什么说我不能使用三角函数? Android 和 Java 不是对 Math.sin 使用相同的算法吗?
  • 如果您在附加调试器的情况下执行此操作,则将其分离 - 您会看到速度显着提高。

标签: java android computation


【解决方案1】:

有什么建议吗?

微基准仅衡量微基准的性能。而且,解释微基准的唯一体面方法是使用微测量。因此,精明的程序员会使用 Traceview 之类的工具来更好地了解他们的时间都花在了哪里。

我怀疑如果您通过 Traceview 运行此程序并查看 LogCat,您会发现您的时间花在了两个方面:

  1. 内存分配和垃圾回收。您的微基准测试正在消耗约 3MB 的堆空间。在生产代码中,你永远不会这样做,至少如果你想保住工作的话。

  2. 浮点运算。根据您的平板电脑,您可能没有浮点协处理器,并且在没有浮点协处理器的 CPU 上进行浮点数学运算非常慢。

如果我用 C 编写代码并使用 Android NDK 会有帮助吗?

好吧,除非您在 Traceview 下分析代码,否则这将很难回答。例如,如果时间主要花在sqrt()cos()sin(),那已经本机代码,你不会变得更快。

更重要的是,即使此微基准测试可能会因本机代码而有所改善,但所做的只是证明此微基准测试可能会因本机代码而有所改善。例如,由于手动堆管理(malloc()free())而不是垃圾收集,对此的 C 翻译可能会更快。但这更像是对微基准测试写得多么糟糕的控诉,而不是关于 C 将快多少的声明,因为生产 Java 代码会比这更好地优化。

除了学习如何使用 Traceview,我建议:

  • 阅读the NDK documentation,因为它包含有关本机代码何时有意义的信息。

  • 阅读Renderscript Compute。在某些设备上,使用 Renderscript Compute 可以将整数数学卸载到 GPU 上,从而大幅提升性能。这对您的浮点微基准测试没有帮助,但对于其他矩阵计算(例如图像处理),Renderscript Compute 可能非常值得研究。

【讨论】:

  • 感谢您的来信。只是一个快速的旁注,在分析后我得到了大约 20% 的三角函数,60% 的“自我”,我相信这意味着我有简单的乘法......
  • @Kasra:如果我正确解释了您的“自我”引用,那么这将是内存分配和内联操作,例如浮点乘法。从垃圾收集的微基准中“窃取”的时间应该在 Traceview 中显示为暂停,似乎什么都没有发生。这假设一个单核 CPU;如果您使用多个核心,则 GC 可能会在另一个核心上运行,并且对性能的影响有限。
  • @Kasra:请注意,理论上,JIT 编译器应该将您的微基准转换为本地指令。我不知道有什么好的方法来确认这一点。您可能希望对平板电脑中的 CPU 进行一些研究。如果是 ARMv7,它将有一个浮点协处理器。如果是 ARMv5,则不会。
【解决方案2】:

当您比较非常不同的架构时,仅处理能力并不是一切。事实上,您很可能不会单独对计算架构进行基准测试。

基准测试的关键因素。 当您处理需要考虑很多变量的事情时,隔离您要测试的那个,并保持其他不变,最好是相等的。

在您的情况下,一些影响结果的变量示例:

  • 实际的计算架构,它本身就是一组复杂的变量(处理器设计和实现、内存层次结构等)
  • 操作系统
  • 上述不同变量的不同 Java 虚拟机实现
  • Dalvik 暗示的附加层

【讨论】:

    【解决方案3】:

    在以下我的众多 Android 基准测试中,至少有八组 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
    

    【讨论】:

    • 也许这是一个愚蠢的问题,但我可以问你Linpack下列出的数字的单位是什么?这是否意味着数字越小计算越快?还是反过来?
    • MFLOPS 是每秒百万次浮点运算 - 浮点计算的标准性能衡量标准 - 当然,高是最好的。
    猜你喜欢
    • 1970-01-01
    • 2018-11-05
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2015-10-18
    • 2013-09-24
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多