我正在为我编写的浮点打印代码编写 JMH 微基准测试。我还不太关心确切的性能，但要确保基准代码正确。

我想循环一些随机生成的数据，因此我制作了一些静态数据数组并保持循环机制（增量和掩码）尽可能简单。这是正确的方法还是我应该告诉 JMH 更多关于我缺少的一些注释的情况？

另外，是否可以为测试制作显示组而不仅仅是字典顺序？我基本上有两组测试（每组随机数据一组。

完整来源位于https://github.com/jnordwick/zerog-grisu

这是基准代码：

package zerog.util.grisu;\n\nimport java.util.Random;\n\nimport org.openjdk.jmh.annotations.Benchmark;\nimport org.openjdk.jmh.runner.Runner;\nimport org.openjdk.jmh.runner.RunnerException;\nimport org.openjdk.jmh.runner.options.Options;\nimport org.openjdk.jmh.runner.options.OptionsBuilder;\n\n/* \n * Current JMH bench, similar on small numbers (no fast path code yet)\n * and 40% faster on completely random numbers.\n * \n * Benchmark                         Mode  Cnt         Score         Error  Units\n * JmhBenchmark.test_lowp_doubleto  thrpt   20  11439027.798 \xc2\xb1 2677191.952  ops/s\n * JmhBenchmark.test_lowp_grisubuf  thrpt   20  11540289.271 \xc2\xb1  237842.768  ops/s\n * JmhBenchmark.test_lowp_grisustr  thrpt   20   5038077.637 \xc2\xb1  754272.267  ops/s\n * \n …

考虑下面的类，它实现了（基本上是为了 MCVE）小字符串优化（假设小尾数、64 位指针等）：

class String {
   char* data_;
   bool sso() const { return reinterpret_cast<uintptr_t>(data_) & 1; }     
 public:
    String(const char * arg = "") {
       auto len = strlen(arg);
       if (len > 6) {
          data_ = new char[len + 1];
          memcpy(data_, arg, len + 1);
       } 
       else {
          data_ = reinterpret_cast<char*>((uintptr_t)1);
          memcpy(reinterpret_cast<char*>(&data_) + 1, arg, len + 1);
       }            
   }  
   ~String() { if (sso() == false) delete data_; }
// ~String() { if (reinterpret_cast<uintptr_t>(data_) & 1 == 0) …

我读到R在矩阵中使用列优先存储，这意味着附近列中的元素存储在连续块或类似的东西中。这让我想知道：是按行填充矩阵更快（byrow=TRUE在基本 R 函数中使用matrix()）还是先按列填充矩阵（使用默认值byrow=FALSE）然后使用转置它更快t()？

我尝试对其进行基准测试。

按行填充矩阵

> microbenchmark(matrix(1, n, n, byrow=TRUE))
Unit: seconds
                          expr      min       lq     mean   median       uq      max neval
 matrix(1, n, n, byrow = TRUE) 1.047379 1.071353 1.105468 1.081795 1.112995 1.628675   100

按列填充矩阵然后转置它

> microbenchmark(t(matrix(1, n, n)))
Unit: seconds
               expr     min       lq     mean  median       uq      max neval
 t(matrix(1, n, n)) 1.43931 1.536333 1.692572 1.61793 1.726244 3.070821   100

结论

似乎按行填充矩阵更快！我错过了什么吗？我原以为这R只会做一些重新标记，t()但实际上比逐行填充矩阵要慢！

对此有解释吗？我很困惑。

观察

在 ThomasIsCoding 的回答和对自己进行了几次基准测试之后，它看起来取决于行数和列数。

• 行数 …

我使用 google benchmark 来测试两个 C++ 函数。一个运行约 630,000,000 ns，另一个运行约 1,000,000,000 ns。但两者都只运行一次迭代。如何强制基准测试运行更多迭代？我希望它至少运行 10 次。

我写了一个小基准，其中程序创建了 的 10 个⁸二维std::vector结构{float, float}，然后将它们的长度平方相加。

这是C++代码：

#include <iostream>
#include <chrono>
#include <vector>
#include <array>
#include <cmath>
    
using namespace std;
using namespace std::chrono;
    
const int COUNT = pow(10, 8);
    
class Vec {
public:
    float x, y;
    
    Vec() {}
    
    Vec(float x, float y) : x(x), y(y) {}
    
    float len() {
        return x * x + y * y;
    }
};
    
int main() {
    vector <Vec> vecs;
    
    for(int i = 0; i < COUNT; ++i) {
        vecs.emplace_back(i …

我想在我的代码中插入一些时间测量。在 x64 上我使用 __rdtscp。mac m1/m2 有类似的东西吗？具体来说，不是系统调用和高分辨率。

我一直以为cld输出中的那一栏microbenchmark是速度的统计排名。然而事实并非如此：

> microbenchmark(
+   intmap = fintmap(), # slower
+   List   = flist(),
+   times = 5
+ )
Unit: microseconds
   expr     min      lq      mean  median       uq      max neval cld
 intmap 793.984 910.539 1145.8608 911.840 1290.529 1822.412     5  a 
   List   1.092   1.318  201.3712   1.639    3.660  999.147     5   b

那么它是什么？该文件只说这是一个统计排名，但是什么？

或者也许这是速度的多重比较测试，但标准差的不等性会导致这样的问题？第二个基准显然存在异常值。

编辑

看来我的问题没有说清楚。a我知道字母和的含义b，这是报告 Tukey 测试的经典方法。但这里的结果并不一致：intmap速度较慢但排名第一。

有谁知道是否有任何YCSB客户端/驱动程序可用于对VoltDB进行基准测试？甚至任何参考出版物/博客/文章/研究项目？

我们可以将TPC工作负载用于VoltDB基准测试吗？

非常感谢大家.

如果我知道那个点的大小,那么传递Collection给Collection构造函数的大小是否更好？扩展Collection和分配/重新分配的节约效果是否显着？

如果我知道最小尺寸Collection而不是上限,该怎么办？至少在最小尺寸的情况下仍然值得创造吗？

我在这篇文章中做了相同的测试: new String()vs literal string performance

意思是我想测试哪一个性能更好.正如我所料,结果是文字的分配更快.我不知道为什么,但我做了测试与一些更多的任务,我发现了一些奇怪:当我让程序做循环分配超过10000次的文字是相对没有那么多比少超过10000级更快的任务.并且在重复1.000.000时,它甚至比创建新对象更慢.

这是我的代码:

double tx = System.nanoTime();
for (int i = 0; i<1; i++){
    String s = "test";
}
double ty = System.nanoTime();

double ta = System.nanoTime();
for (int i = 0; i<1; i++){
    String s = new String("test");
}
double tb = System.nanoTime();

System.out.println((ty-tx));
System.out.println((tb-ta));

我让它像上面写的那样运行.我只是在学习Java,而我的老板让我做测试,在我提出测试结果后,他让我找到答案,为什么会这样.我在谷歌或stackoverflow上找不到任何东西,所以我希望有人可以帮助我.

factor at         1 repetition   3,811565221
factor at        10 repetitions  4,393570401
factor at       100 repetitions  5,234779103
factor at     1,000 repetitions  7,909884116
factor at    10,000 repetitions  9,395538811
factor at   100,000 …