标签: microbenchmark

我正在阅读MHZ - lmbench的创建者和源代码浏览代码的基准论文解剖.

1. 该论文可以下载@ MHz:Microbenchmark解剖
2. 源代码lmbench-3.0由Carl Staelin和Larry McVoy撰写

在BENCH_INNER()宏内部,我有一个疑问:

#define BENCH_INNER(loop_body, enough) {                \
    static iter_t   __iterations = 1;               \
    int     __enough = get_enough(enough);          \
    iter_t      __n;                        \
    double      __result = 0.;                  \
                                    \
    while(__result < 0.95 * __enough) {             \
        start(0);                       \
        for (__n = __iterations; __n > 0; __n--) {      \
            loop_body;                  \
        }                           \
        __result = stop(0,0);                   \
        if (__result < 0.99 * __enough              \
            || __result > 1.2 * …

如果我想对我的 Java 类中的方法进行基准测试，哪个是更好的选择？两者之间的优缺点是什么？

考虑以下 x86 程序集：

; something that sets rax
mov rcx, [rdi]
xor rax, rcx
xor rax, rcx

在序列末尾，rax的值与进入时的值相同，但从 CPU 的角度来看，它的值取决于从内存加载到 的值rcx。特别是，rax在该加载和两条指令完成之前，后续的使用不会开始xor。

有没有什么方法可以比双xor序列更有效地实现这种效果，例如，使用单个单微指令单周期延迟指令？如果某个常量值需要在序列之前设置一次（例如，有一个归零的寄存器），这是可以的。

As far as I know, the main difference in runtime ordering in a processor with respect to rdtsc and rdtscp instruction is that whether the execution waits until all previous instructions are executed locally.

In other words, it means lfence + rdtsc = rdtscp because lfence preceding the rdtsc instruction makes the following rdtsc to be executed after all previous instruction finish locally.

However, I've seen some example code that uses rdtsc at the start of measurement and rdtscp at …

我正在使用 Google Benchmark 优化一个函数，并遇到了我的代码在某些情况下意外变慢的情况。我开始试验它，查看编译后的程序集，并最终想出了一个最小的测试用例来展示这个问题。这是我想出的展示这种放缓的程序集：

    .text
test:
    #xorps  %xmm0, %xmm0
    cvtsi2ss    %edi, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    addss   %xmm0, %xmm0
    retq
    .global test

此函数遵循 GCC/Clang 的 x86-64 函数声明调用约定extern "C" float test(int);注意注释掉的xorps指令。取消注释此指令可显着提高函数的性能。用我的机器有i7-8700K，谷歌基准测试显示的功能测试它，而不该xorps指令需要8.54ns（CPU），而功能与该xorps指令需要1.48ns。我已经在具有不同操作系统、处理器、处理器世代和不同处理器制造商（英特尔和 AMD）的多台计算机上对此进行了测试，它们都表现出类似的性能差异。重复addss指令使减速更加明显（在某种程度上），并且这种减速仍然使用此处的其他指令（例如mulss）或什至混合指令发生，只要它们都%xmm0以某种方式依赖于值。值得指出的是，只调用xorps 每个函数调用会导致性能提升。使用循环对性能进行采样（如 Google Benchmark 所做的那样）和xorps循环外的调用仍然显示出较慢的性能。

由于这是一种专门添加指令可以提高性能的情况，因此这似乎是由 CPU 中的一些非常低级的东西引起的。由于它发生在各种 CPU …

我们正在为我们的堆栈评估 GraalVM。主要考虑因素之一是性能，这里有一些基准： https: //renaissance.dev/。

问题是我们希望看到其他语言实现的基准，而不是 OpenJDK 和 GraalVM 版本之间的基准。我唯一能找到的就是这篇文章，将它与 C2 进行比较。https://medium.com/graalvm/graalvm-20-1-7ce7e89f066b

我们的谷歌搜索没有发现任何其他结果。

我们在哪里可以找到更广泛的、跨语言的 GraalVM 基准测试？

我已阅读 CSAPP 3e 的第 5 章。我想测试一下书中描述的优化技术是否可以在我的计算机上运行。我编写了以下程序：

#define SIZE (1024)
int main(int argc, char* argv[]) {
  int sum = 0;
  int* array = malloc(sizeof(int) * SIZE);
  unsigned long long before = __rdtsc();
  for (int i = 0; i < SIZE; ++i) {
    sum += array[i];
  }
  unsigned long long after = __rdtsc();
  double cpe = (double)(after - before) / SIZE;
  printf("CPE is %f\n", cpe);
  printf("sum is %d\n", sum);
  return 0;
}

据报道，CPE 约为 1.00。

我使用 4x4 循环展开技术转换程序，得到以下程序：

#define SIZE (1024)
int …

我认为每个 C++ 程序员都曾在某个时候听说过“虚拟函数很慢”这句话。因此，我决定将虚拟函数与常规成员函数进行基准测试。

不幸的是，我在对“低级”C++ 代码进行基准测试方面没有太多经验，并且不知道如何正确避免编译器或硬件（主要是分支预测器）优化效果。

我现在面临的问题是，当我运行基准测试（我在下面提供）时，我几乎总是得到调用虚拟函数和常规函数具有相同速度的结果，有时虚拟函数工作得更快！

这就是我使用google/benchmark库编写基准的方式：

static void BM_MemberCall(benchmark::State& state) {
    Base* b = new Derived();

    for ([[maybe_unused]] auto _ : state) {
        benchmark::DoNotOptimize(b->Foo());
        benchmark::ClobberMemory();
    }
}
BENCHMARK(BM_MemberCall);

static void BM_VirtualCall(benchmark::State& state) {
    Base* b = new Derived();

    for ([[maybe_unused]] auto _ : state) {
        benchmark::DoNotOptimize(b->VirtualFoo());
        benchmark::ClobberMemory();
    }
}
BENCHMARK(BM_VirtualCall);

我的类定义如下，声明于util.h：

#pragma once

// generate 10 virtual functions
#define VFOO(NAME, ID, ...) \
    __attribute__((noinline)) virtual int NAME ## ID ## _0() __VA_ARGS__; \
    __attribute__((noinline)) virtual …

很抱歉问新手问题.我不知道如何解释microbenchmark结果中的lq和uq列.这是一个例子:

Unit: microseconds
       expr      min       lq   median       uq         max neval
f(1000, 1) 1082.875 1139.485 1151.071 1162.327 1199918.296  1000
g(1000, 1)  193.004  219.157  221.806  228.427    1099.097  1000

我想分析JMH测试并查看像VisualVM中一样的调用树。但是，当我使用StackProfiler时，它为我提供了诸如此类的本机方法，这对我而言完全没有用。

....[Thread state distributions]....................................................................
 59,9%         TIMED_WAITING
 23,0%         WAITING
 17,0%         RUNNABLE

....[Thread state: TIMED_WAITING]...................................................................
 47,3%  78,9% sun.misc.Unsafe.park
  8,3%  13,8% java.lang.Thread.sleep
  4,4%   7,3% java.lang.Object.wait

....[Thread state: WAITING].........................................................................
 21,9%  95,1% sun.misc.Unsafe.park
  1,1%   4,9% java.lang.Object.wait

....[Thread state: RUNNABLE]........................................................................
 13,5%  79,0% sun.nio.ch.EPollArrayWrapper.epollWait
  2,0%  11,5% java.net.SocketInputStream.socketRead0
  1,0%   5,7% java.net.PlainSocketImpl.socketAccept