1

我一直在查看一些示例程序，以便找到更好的使用 Dart 编码的方法。

并不是说这个例子（下面）有什么特别重要的，但是它取自 Rosettacode dot org，我做了一些改动（希望）让它保持最新。

这篇文章的重点是关于基准测试，以及与其他语言相比，就打印到控制台的速度而言，在某些基准测试中可能不利于 Dart 的结果。我不知道比较是什么（与其他语言），但是在 Dart 中，即使使用 StringBuffer，控制台输出（至少在 Windows 中）似乎也很慢。

顺便说一句，在我的测试中，如果允许 n1 增长到 11，则总递归数 = >2.38 亿，并且它需要（在我的笔记本电脑上）c。运行示例 1 需要 2.9 秒。

此外，可能感兴趣的是，如果将 String 分配更改为 int，而不打印，则不会将任何时间记录为经过（示例 2）。

我的低规格笔记本电脑上的典型时间（从控制台运行 - Windows）。

Elapsed Microseconds (Print) = 26002
Elapsed Microseconds (StringBuffer) = 9000
Elapsed Microseconds (no Printing)   = 3000

显然，在这种情况下，控制台打印时间是相对于计算等时间的重要因素。

那么，任何人都可以建议这与例如相比如何。控制台输出的 Java 时间？这至少表明 Dart 在该领域是否特别慢，这可能与某些基准有关。顺便说一句，在 Dart 编辑器中运行时，打印的损失可以忽略不计。

// Example 1. The base code for the test (Ackermann).

main() {
  for (int m1 = 0; m1 <= 3; ++m1) {
    for (int n1 = 0; n1 <= 4; ++n1) {
      print ("Acker(${m1}, ${n1}) = ${fAcker(m1, n1)}");
    }
  }
}

int fAcker(int m2, int n2) => m2==0 ? n2+1 : n2==0 ?
    fAcker(m2-1, 1) : fAcker(m2-1, fAcker(m2, n2-1));

测试的更改代码。

// Example 2 //
main() {
  fRunAcker(1);   // print
  fRunAcker(2);   // StringBuffer
  fRunAcker(3);   // no printing
}

void fRunAcker(int iType) {
  String sResult;
  StringBuffer sb1;
  Stopwatch oStopwatch = new Stopwatch();
  oStopwatch.start();
  List lType = ["Print", "StringBuffer", "no Printing"];
  if (iType == 2)   // Use StringBuffer
    sb1 = new StringBuffer();

  for (int m1 = 0; m1 <= 3; ++m1) {
    for (int n1 = 0; n1 <= 4; ++n1) {
      if (iType == 1)   // print
        print ("Acker(${m1}, ${n1}) = ${fAcker(m1, n1)}");
      if (iType == 2)   // StringBuffer
        sb1.write ("Acker(${m1}, ${n1}) = ${fAcker(m1, n1)}\n");
      if (iType == 3)   // no printing
        sResult = "Acker(${m1}, ${n1}) = ${fAcker(m1, n1)}\n";
    }
  }
  if (iType == 2)
    print (sb1.toString());
  oStopwatch.stop();
  print ("Elapsed Microseconds (${lType[iType-1]}) = "+ 
   "${oStopwatch.elapsedMicroseconds}");
}
int fAcker(int m2, int n2) => m2==0 ? n2+1 : n2==0 ?
    fAcker(m2-1, 1) : fAcker(m2-1, fAcker(m2, n2-1));

//Typical times on my low-spec laptop (run from the console).
   //   Elapsed Microseconds (Print) = 26002
   //   Elapsed Microseconds (StringBuffer) = 9000
   //   Elapsed Microseconds (no Printing)   = 3000
4

2 回答 2

0

我对控制台打印进行了进一步的测试，如下所示（示例 1 - Dart），（示例 2 - Java）。

每个的最佳时间如下（100,000 次迭代）：

飞镖 47 秒。
Java 22 秒。
飞镖编辑器 2.3 秒。

虽然它不是惊天动地的，但它似乎确实说明了出于某种原因
(a) Dart 在控制台输出上很慢，并且
(b) Dart-Editor 在控制台输出上非常快。
(c) 在评估任何涉及控制台输出的性能时，需要考虑到这一点，这是最初引起我注意的地方。

也许当他们有时间时 :) 如果认为值得，Dart 团队可以研究一下。

示例 1 - 飞镖

// Dart - Test 100,000 iterations of console output //

Stopwatch oTimer = new Stopwatch(); 

main() {
  // "warm-up"
  for (int i1=0; i1 < 20000; i1++) {
    print ("The quick brown fox chased ...");
  }


  oTimer.reset();
  oTimer.start();
  for (int i2=0; i2 < 100000; i2++) {
    print ("The quick brown fox chased ....");
  }
  oTimer.stop();
  print ("Elapsed time = ${oTimer.elapsedMicroseconds/1000} milliseconds");
}

示例 2 - Java

  public class console001
  {
  // Java - Test 100,000 iterations of console output 

  public static void main (String [] args)
  {
     //  warm-up
     for (int i1=0; i1<20000; i1++)
     {
        System.out.println("The quick brown fox jumped ....");
     }

     long tmStart = System.nanoTime();
     for (int i2=0; i2<100000; i2++)
     {
        System.out.println("The quick brown fox jumped ....");
     }

     long tmEnd = System.nanoTime() - tmStart;
     System.out.println("Time elapsed in microseconds = "+(tmEnd/1000));
  }
}
于 2013-05-29T07:09:39.243 回答
0

我使用 Java 进行了测试，这是一个有趣的练习。

这个小测试的结果表明，Dart 在控制台输出上花费的时间比 Java 长约 60%，每个测试都使用了最快的结果。我真的需要用更多的终端输出做一个更大的测试，我会这样做。

在没有输出的“计算”速度方面，使用这个测试并且 m = 3 和 n = 10，Java 的比较始终在 530 毫秒左右，而 Dart 的比较是 580 毫秒。那是5950万个电话。n = 11（2.38 亿次调用）的 Java 炸弹，我认为这是堆栈溢出。我并不是说这是一个明确的基准，但它表明了一些事情。Dart 在计算时间上似乎非常接近，这是令人高兴的。我将 Dart 代码从使用“问号运算符”更改为使用与 Java 相同的“if”语句，这似乎要快一些 c. 10% 或更多，而且情况似乎一直如此。

于 2013-05-28T20:33:50.963 回答