我最近开始学习 Go，我正在尝试实现一个可以由多个 groutine 同时使用的地图。我希望能够将我的实现与简单的sync.Mutex受保护的映射或类似的东西进行比较： https://github.com/streamrail/concurrent-map/blob/master/concurrent_map.go

通过使用 Google Caliper，我认为一种幼稚的基准测试方法会导致许多不需要的优化，从而破坏实际结果。使用的基准测试是否testing.B采用了一些技术来避免这种情况（毕竟 Go 和 Caliper 都是 Google 项目）？如果有，他们是已知的吗？如果不是，那么在 Go 中进行微基准测试的最佳方法是什么？

首先，我在 IvyBridge 上进行了以下设置，我将在注释位置插入测量有效负载代码。前 8 个字节buf存储buf自身的地址，我用它来创建循环携带依赖：

section .bss
align   64
buf:    resb    64

section .text
global _start
_start:
    mov rcx,         1000000000
    mov qword [buf], buf
    mov rax,         buf
loop:
    ; I will insert payload here
    ; as is described below 

    dec rcx
    jne loop

    xor rdi,    rdi
    mov rax,    60
    syscall

情况1：

我插入到有效载荷位置：

mov qword [rax+8],  8
mov rax,            [rax]

perf显示循环为 5.4c/iter。有点理解，因为L1d延迟是4个周期。

案例2：

我颠倒了这两条指令的顺序：

mov rax,            [rax]
mov qword [rax+8],  8

结果突然变成9c/iter。我不明白为什么。因为下一次迭代的第一条指令不依赖于当前迭代的第二条指令，所以这个设置应该和 case 1 没有区别。

我也用IACA工具对这两种情况进行静态分析，但是该工具不可靠，因为两种情况预测的结果都是5.71c/iter，与实验相矛盾。 …

为什么这里的sub eins与else比慢sub zwei用elsif？

#!/usr/bin/env perl
use warnings;
use 5.012;
use Benchmark qw(:all);

my $d = 0;
my $c = 2;

sub eins {
    if ( $c == 1) {
        $d = 1;
    }
    else {
        $d = 2;
    }
}

sub zwei {
    if ( $c == 1) {
        $d = 1;
    }
    elsif ( $c == 2 ) {
        $d = 2;
    }
}

sub drei {
    $d = 1;
    $d …

在编写微基准测试时,可以观察到运行时的巨大差异,具体取决于方法是否已编译.有没有办法从程序中判断是否编译了特定方法？或者,是否有一种方法可以请求它,或者知道如何在没有任何额外信息(例如传递给JVM的标志)的情况下充分加热它？显然,这不一定是完美的(例如,可能存在一些导致JVM回退到解释代码的条件),但它肯定会有所改进.

我想知道a!=0比!a==0使用R包microbenchmark 快多少.这是代码(如果你的电脑很慢,减少3e6和100):

library("microbenchmark")
a <- sample(0:1, size=3e6, replace=TRUE)
speed <- microbenchmark(a != 0, ! a == 0, times=100)
boxplot(speed, notch=TRUE, unit="ms", log=F)

每次,我得到一个类似下面的情节.正如所料,第一个版本比第二个版本(33毫秒)更快(中位数为26毫秒).

但这几个非常高的值(异常值)来自哪里呢？是一些内存管理效果？如果我将时间设置为10,则没有异常值......

编辑:sessionInfo():R版本3.1.2(2014-10-31)平台:x86_64-w64-mingw32/x64(64位)

我做了一个很少迭代的测试来测试Document.querySelector和 的效率Element.querySelector。

标记：

<form>
  <input type="text" />
</form>

脚本：

查询 Document.querySelector

begin = performance.now();

var 
  i = 0,
  iterations = 999999;

for ( i; i < iterations; i++ ) 
{
 element = document.querySelector('[type="text"]');
}

end = performance.now();

firstResult = end - begin;

查询 Element.querySelector

begin = performance.now();

var 
  i = 0,
  iterations = 999999,
  form = document.querySelector('form');

for ( i; i < iterations; i++ ) 
{
 element = form.querySelector('[type="text"]');
}

end = performance.now();

secondResult = end …

我有一个非常简单的微基准测试

@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
public class Test {

  List<Integer> list =  new Random().ints(100_000).boxed().collect(toList());

  @Benchmark public int mapToInt() {
    return list.stream().mapToInt(x -> x * x).sum();
  }
}

当我运行它时,我总是得到一个结果,第一次热身运行比下一次运行快得多:

# Warmup Iteration   1: 171.596 us/op
# Warmup Iteration   2: 689.337 us/op
....
Iteration   1: 677.625 us/op
....

命令行:

java -jar target/benchmarks.jar .*Test.* -wi 5 -w 1000ms -i 10 -r 1000ms -t 1 -f 5 -tu us

玩叉子或线程的数量似乎没有什么区别.

所以看起来有些优化会被恢复,但我找不到它是什么.

由于我的基准测试问题导致性能下降,还是这种去优化代表了实际应用中会发生什么？

_{注意:这是一个后续工作是否有任何优势在mapToInt之后调用map,哪里需要？}

我最近发现两个宏之间存在巨大差异:@benchmark和@time在内存分配信息和时间方面.例如:

@benchmark quadgk(x -> x, 0., 1.)
BenchmarkTools.Trial: 
memory estimate:  560 bytes
allocs estimate:  17
--------------
minimum time:     575.890 ns (0.00% GC)
median time:      595.049 ns (0.00% GC)
mean time:        787.248 ns (22.15% GC)
maximum time:     41.578 ?s (97.60% GC)
--------------
samples:          10000
evals/sample:     182

@time quadgk(x -> x, 0., 1.)
0.234635 seconds (175.02 k allocations: 9.000 MiB)
(0.5, 0.0)

为什么这两个例子之间有很大的不同？

我正在尝试构建 google-benchmark 并使用 cmake 将它与我的库一起使用。我已经成功构建了 google-benchmark 并使用 cmake 成功运行了所有测试。不幸的是，我无法使用 cmake 或 cl 在 windows 中将它与我的 c++ 代码正确链接。

我认为的问题是 google-benchmark 在 src 文件夹中构建库，即它构建在 src/Release/benchmark.lib 现在我不能在 cmake 中指向它，如果我使用 ${benchmark_LIBRARIES} 它在src 外的 Release 文件夹，因为这是构建所有库的常用位置。并且很难找到在 Windows 中工作的示例。

这是我尝试过的两种方法，都可以构建库并运行所有测试，但我无法正确地将库指向 target_link_library

include(ExternalProject)
ExternalProject_Add(googlebenchmark
  GIT_REPOSITORY    https://github.com/google/benchmark.git
  GIT_TAG           master
  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src"
  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build"
  CONFIGURE_COMMAND ${CMAKE_COMMAND} -B ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build -S ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
  BUILD_COMMAND     ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build --config Release 
  INSTALL_COMMAND   ""
  TEST_COMMAND      ${CMAKE_CTEST_COMMAND} ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build --build-config Release 
)

和

ExternalProject_Add(googlebenchmark
  GIT_REPOSITORY    https://github.com/google/benchmark.git
  GIT_TAG           master 
  PREFIX            googlebenchmark
  CMAKE_ARGS        -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
  BUILD_COMMAND     ${CMAKE_COMMAND} --build …

请注意，我之前尝试在此问题中对此进行测试，这可能看起来相似，但是这些结果存在缺陷并且是不断折叠的结果，我随后将其禁用。并在此问题中重新发布。

鉴于这两个 evals（评论一个关于执行）只改变&Module::FOO()和&FOO()。

# Symbols imported, and used locally.
eval qq[ 
  package Foo$num;
  Module->import();
  my \$result = &Module::FOO() * &Module::FOO();
] or die $@;

# Symbols imported, not used locally referencing parent symbol.
eval qq[ 
  package Foo$num;
  Module->import();
  my \$result = &FOO() * &FOO();
] or die $@;

为什么会顶块占据显着更少的空间？脚本和输出复制如下，

脚本

package Module {
  use v5.30;
  use warnings;
  use constant FOO => 42; 
  use Exporter 'import';
  our …