标签: microbenchmark

注意：问题末尾给出了详尽的系统详细信息。

我试图让我的开发机器具有非常稳定的 CPU 频率，以便我可以获得一些线性代数代码的精确基准 - 然而，它仍然显示出明显的频率波动。

我已将缩放调节器设置为performance模式：

echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

我还锁定了C0状态中的所有内容：

sudo cpupower idle-set -D 0

然而，使用 时i7z，我仍然观察到 CPU 频率波动 >5%。我非常感谢有关我是否应该采取进一步步骤将 CPU 频率限制为固定值，或者是否无法获得更精确的频率限制的指导。

附录：

我的处理器是 Intel Core i7-9750H：

cat /proc/cpuinfo | grep 'model name' 
model name  : Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
...

它有 12 个逻辑 CPU 和 6 个物理核心：

lscpu -a -e
CPU NODE SOCKET CORE L1d:L1i:L2:L3 ONLINE MAXMHZ    MINMHZ
0   0    0      0    0:0:0:0       yes    4500.0000 800.0000
1 …

我想评估使用不同文件类型（geotiff、二进制）或对象（RasterBrick、RasterStack）从栅格时间序列中提取数据的时间。我创建了一个函数，该函数将从栅格​​对象的随机点提取时间序列，然后使用微基准测试它。

前任。：

# read a random point from a raster stack
sample_raster <- function(stack) {
  poi <- sample(ncell(stack), 1)
  raster::extract(stack, poi)
}

# opening the data using different methods
data_stack <- stack(list.files(pattern = '3B.*tif'))
data_brick <- brick('gpm_multiband.tif')

bench <- microbenchmark(
  sample_stack = sample_raster(data_stack),
  sample_brick = sample_raster(data_brick),
  times = 10
)

boxplot(bench)

# this fails because sampled point is different
bench <- microbenchmark(
  sample_stack = sample_raster(data_stack),
  sample_brick = sample_raster(data_brick),
  times = 10,
  check = 'equal'
)

我在此处包含了我的数据集的示例

由此，我可以看到RasterBrick上的采样比堆栈更快（R …

我有一个类似的代码：

...
void benchMark(benchmark::State& state){
    maxCapacity = state.range(0);
    // set up some stuff
    for (auto _ : state){
        // time this code
    }
}

BENCHMARK(benchMark)->DenseRange(2, 10, 1);
BENCHMARK_MAIN();

我想把它改成这样：

...
void benchMark(benchmark::State& state){
    maxCapacity = state.range(0);
    // set up some stuff
    for (auto _ : state){
        // time this code
    }
}

int main(){
    BENCHMARK(benchMark)->DenseRange(2, 10, 1);
}

我这样做只是为了以后可以为代码提供命令行参数支持。现在这段代码编译成功，但我根本没有得到任何输出。我猜代码甚至没有运行。第一个代码需要 5 分钟才能完成，但第二个代码几乎立即完成执行。我究竟做错了什么？

任何帮助都会很棒。谢谢..

编辑：

由于我无法分享完整的代码，这里有一个最小的可重现示例：

#include <iostream>
#include <benchmark/benchmark.h>
using namespace std;

void pointQuery(int maxCapacity){
    long sum = 0;
    for(int i=0; …

我有一个非常简单的程序来测量一个函数花费了多少时间。

#include <iostream>
#include <vector>
#include <chrono>
struct Foo
{
    void addSample(uint64_t s)
    {
    }
};

void test(const std::vector<uint64_t>& samples)
{
    uint32_t onlyCallTime = 0;
    uint32_t loopOnlyTime = 0;
    Foo stats;
    std::chrono::high_resolution_clock::time_point callStart,callEnd;
    auto start = callStart = callEnd = std::chrono::high_resolution_clock::now();
    for(auto &s : samples)
    {
        callStart = std::chrono::high_resolution_clock::now();
        loopOnlyTime += std::chrono::duration_cast<std::chrono::microseconds>(callStart-callEnd).count();
        stats.addSample(s);
        callEnd = std::chrono::high_resolution_clock::now();
        onlyCallTime += std::chrono::duration_cast<std::chrono::microseconds>(callEnd-callStart).count();
    }
    auto end = std::chrono::high_resolution_clock::now();

    std::cout << "overall duration: " << std::chrono::duration_cast<std::chrono::microseconds>(end-start).count() << std::endl;
    std::cout << "only call duration: " << …

我想用 JMH 来衡量斐波那契函数的性能。但编译时出现以下错误：

Exception in thread "main" java.lang.RuntimeException: ERROR: Unable to find the resource: /META-INF/BenchmarkList
    at jmh.core@1.34/org.openjdk.jmh.runner.AbstractResourceReader.getReaders(AbstractResourceReader.java:98)
    at jmh.core@1.34/org.openjdk.jmh.runner.BenchmarkList.find(BenchmarkList.java:124)
    at jmh.core@1.34/org.openjdk.jmh.runner.Runner.internalRun(Runner.java:253)
    at jmh.core@1.34/org.openjdk.jmh.runner.Runner.run(Runner.java:209)
    at jmh.core@1.34/org.openjdk.jmh.Main.main(Main.java:71)
    at project/Mypackage.BenchmarkRunner.main(BenchmarkRunner.java:6)

我使用 IntelliJ IDEA 我使用 openJDK 16

我尝试在资源目录中添加文件夹和文件/META-INF/BenchmarkList 我遇到此错误：

No matching benchmarks. Miss-spelled regexp?
Use EXTRA verbose mode to debug the pattern matching.

我的主要课程开始基准测试：

Exception in thread "main" java.lang.RuntimeException: ERROR: Unable to find the resource: /META-INF/BenchmarkList
    at jmh.core@1.34/org.openjdk.jmh.runner.AbstractResourceReader.getReaders(AbstractResourceReader.java:98)
    at jmh.core@1.34/org.openjdk.jmh.runner.BenchmarkList.find(BenchmarkList.java:124)
    at jmh.core@1.34/org.openjdk.jmh.runner.Runner.internalRun(Runner.java:253)
    at jmh.core@1.34/org.openjdk.jmh.runner.Runner.run(Runner.java:209)
    at jmh.core@1.34/org.openjdk.jmh.Main.main(Main.java:71)
    at project/Mypackage.BenchmarkRunner.main(BenchmarkRunner.java:6)

以及我想要衡量其性能的斐波那契方法的课程

No matching benchmarks. Miss-spelled …

如何强制计算表达式，使其不会被优化？

@elapsed f()返回零，因为纯函数的结果f未被使用。

在 Rust 中，我们可以使用一个名为 的内在函数black_box，在 Nim - usedpragma 中，在 C 中我们可以创建一个volatile变量，在 Zig -doNotOptimizeAway函数中，在 Haskell 中我们可以使用它evaluate来强制求值，等等。我怎样才能在朱莉娅做到这一点？

另外，@elapsed实际上是测量经过时间的正确方法吗？我个人需要一个具有纳秒精度的单调计时器......

对于ELKI,我需要(并且拥有)比标准Java JDK和Collections API提供的更灵活的排序实现.(排序不是我的最终目标.我使用部分排序来批量加载索引结构,例如kd-tree和R*-tree,我希望对这些结构进行相当通用的实现,比目前在ELKI中更通用 - 但不管怎样,优化排序意味着优化索引构建时间.

但是,排序算法根据您的数据大小而有很大差异.对于小型数组,已知的事实是插入排序可以很好地执行(事实上,大多数快速排序实现将回退到低于某个阈值的插入排序); 不是理论上的,而是通过排序理论不考虑的CPU流水线和代码大小效应.

所以我现在正在对许多排序实现进行基准测试,以找到满足我特定需求的最佳组合; 我希望我的更灵活的实现与JDK默认实现(已经很好地调整,但可能用于不同的JDK版本)相当.

从长远来看,我需要这些东西易于重现和重新运行.在某些时候,我们将看到JDK8.在Dalvik VM上,结果也可能与Java 7不同.哎呀,他们甚至可能在AMD,Core i7和Atom CPU上也有所不同.因此,Cervidae可能会包含不同的排序策略,并在课程加载时选择最合适的排序策略.

我目前的努力是在GitHub上:https://github.com/kno10/cervidae

所以现在对实际的问题.最新的caliper commit为macrobenchmarks添加了一些实验代码.不过,我面对我需要的问题都.当运行时间小于定时器分辨率的0.1%时,Caliper宏基准测试失败; 有10000个对象,一些算法达到了这个阈值.与此同时,microbenchmarks抱怨说,当你的运行时间过长时,你应该做一个宏基准测试......

因此,对于不同排序大小的基准测试,我实际上需要一种根据运行时动态从微基准标记切换到宏基准标记的方法.实际上,我甚至更喜欢如果caliper会自动地意识到运行时足够大以进行宏基准测试,然后只进行一次迭代.

现在,我试图通过使用以下方式来模拟这个:

@Macrobenchmark
public int macroBenchmark() { ... }

public int timeMicroBenchmark(int reps) {
    int ret = 0;
    for (int i = 0; i < reps; i++) {
        ret += macroBenchmark();
    }
}

在两种方案中共享基准测试代码.另一个代码是使用

@Macrobenchmark
public int macroBenchmark() {
    return timeMicroBenchmark(1);
}

public int timeMicroBenchmark(int reps) { ... }

两个"适配器"中哪一个更受欢迎？任何其他提示从微观一直到宏一致的基准测试？

鉴于卡尺WebUI当前不起作用,您使用什么来分析结果？我目前正在使用一个小的python脚本来处理JSON结果并报告加权方法.事实上,我喜欢旧文本报告比Web UI更好.

哦,有没有办法让Caliper在基准测试循环中发生Hotspot编译时重新运行基准测试？现在它记录了一个错误,但也许它可以重新启动那部分基准测试？

我已经对下面的代码进行了微观基准测试,我注意到一些有趣的东西,我希望有人可以更多地了解它.它导致一种情况,它看起来像一个for循环可以继续运行,同时阻止JVM中的其他线程.如果这是真的那么我想理解为什么,如果它不是真的那么任何洞察我可能遗失的东西将不胜感激.

为了建立这种情况,让我引导您完成我正在运行的基准测试及其结果.

代码非常简单,迭代数组中的每个元素,对其内容求和.重复'targetCount'次.

public class UncontendedByteArrayReadBM extends Benchmark {

private int arraySize;
private byte[] array;

public UncontendedByteArrayReadBM( int arraySize ) {
    super( "array reads" );

    this.arraySize = arraySize;
}

@Override
public void setUp() {
    super.setUp();

    array = new byte[arraySize];
}

@Override
public void tearDown() {
    array = null;
}

@Override
public BenchmarkResult invoke( int targetCount ) {
    long sum = 0;
    for ( int i=0; i<targetCount; i++ ) {
        for ( int j=0; j<arraySize; j++ ) {
            sum += array[j]; …

我有一个Caliper基准测试,看起来像这样:

public Course timeCourseCreation( int i ) {

  return createCourse( i );
}

public Course createCourse( int t ) {

  Course course = new Course();

  for ( int i = 0 + t; i < this.students + t; i++ ) {
    Student student = new Student();
    student.setAge( ( int ) ( 100 * Math.random() ) + t );
    student.setName( UUID.randomUUID().toString() );
    course.getStudents().add( student );
  }

  for ( int i = 0 + t; i < this.courses + t; i++ ) …

我目前的设置:

    public void launchBenchmark() throws Exception {
    Options opt = new OptionsBuilder()
            .include(this.getClass().getName())
            .mode(Mode.Throughput) //Calculate number of operations in a time unit.
            .mode(Mode.AverageTime) //Calculate an average running time per operation
            .timeUnit(TimeUnit.MILLISECONDS)
            .warmupIterations(1)
            .measurementIterations(30)
            .threads(Runtime.getRuntime().availableProcessors())
            .forks(1)
            .shouldFailOnError(true)
            .shouldDoGC(true)
            .build();

    new Runner(opt).run();
}

如何知道/控制(如果可能)每个基准测试执行的操作数量？

设置暖启时间和测量迭代时间是否重要？

谢谢.