java - 处理能力 - 移动设备与台式机 - 100 倍的差异？

Question

有没有人比较过移动设备和 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;
    }


}

Answer 1

Any suggestion?

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

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

1. 内存分配和垃圾收集。您的微基准正在咀嚼 ~3MB 的堆空间。在生产代码中，您永远不会这样做，至少如果您想保住工作的话。

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

Does it help if I write the code in C and use Android NDK?

嗯，除非您在 Traceview 下剖析代码，否则很难回答这个问题。例如，如果时间主要花在 sqrt()、cos() 和 sin() 上，那已经 native 代码，你不会变得更快。

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

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

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

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