标签: benchmarking

我对使用算法交易策略感兴趣.有没有人知道我是否可以使用离线播放的模拟器或基准数据(实际上没有进行任何投资)？

我有一组n个向量存储在3 xn矩阵中z.我找到了外用产品np.einsum.当我使用时间计时:

%timeit v=np.einsum('i...,j...->ij...',z,z)

我得到了结果:

The slowest run took 7.23 times longer than the fastest. This could mean that an
intermediate result is being cached 
100000 loops, best of 3: 2.9 µs per loop

这里发生了什么,可以避免吗？最好的3是2.9us,但最慢可能更典型.

我需要浏览一个包含大约一万个文件的文件夹.我的旧vbscript在处理这个问题时非常缓慢.从那时起我就开始使用Ruby和Python,我在三种脚本语言之间做了一个基准测试,看看哪种语言最适合这项工作.

以下测试的结果是共享网络上4500个文件的子集

Python: 106 seconds
Ruby: 5 seconds
Vbscript: 124 seconds

Vbscript会是最慢的并不奇怪,但我无法解释Ruby和Python之间的区别.我对Python的测试不是最佳的吗？有没有更快的方法在Python中执行此操作？

thumbs.db的测试仅用于测试,实际上还有更多的测试要做.

我需要一些东西来检查路径上的每个文件,并且不会产生太多输出而不会干扰时序.结果每次运行都有点不同,但不是很多.

#python2.7.0
import os

def recurse(path):
  for (path, dirs, files) in os.walk(path):
    for file in files:
      if file.lower() == "thumbs.db":
        print (path+'/'+file)

if __name__ == '__main__':
  import timeit
  path = '//server/share/folder/'
  print(timeit.timeit('recurse("'+path+'")', setup="from __main__ import recurse", number=1))

'vbscript5.7
set oFso = CreateObject("Scripting.FileSystemObject")
const path = "\\server\share\folder"
start = Timer
myLCfilename="thumbs.db"

sub recurse(folder)
  for each file in folder.Files
    if lCase(file.name) = myLCfilename then
      wscript.echo file
    end if
  next …

在我的Go包中有几个像map1_benchmark_test.go和的基准文件map2_benchmark_test.go.在每个*_benchmark_test.go文件中,都有不止一个基准函数,比如func BenchmarkMapTravel(b *testing.B)和func BenchmarkMapGet(b *testing.B).

问题是,我怎样才能测试一个基准函数？

我试图阅读一些手册,并且通过运行得不到基准go help test.

当我运行我的基准时go test -v -bench=. -benchmem,我看到以下结果.

f1     10000        120860 ns/op        2433 B/op         28 allocs/op
f2     10000        120288 ns/op        2288 B/op         26 allocs/op

根据我的理解:

1. 10000是迭代次数for i := 0; i < b.N; i++ {.
2. XXX ns/op 是一次迭代完成所需的大致时间

但即使阅读了文档后,我也无法找到什么B/op和allocs/op意思.

我的猜测是,allocs/op与垃圾收集和内存分配有关(越少越好).

任何人都可以对这些值的含义做出很好的解释.同样很高兴知道为什么要上升和减少它们的主要步骤(我意识到这是测试特定的,但可能有一些通用提示在许多情况下都有效)

很长一段时间以来,我一直认为C++比JavaScript更快.然而,今天我制作了一个基准脚本来比较两种语言中浮点计算的速度,结果令人惊叹!

JavaScript似乎比C++快4倍!

我让这两种语言在我的i5-430M笔记本电脑上做同样的工作,执行a = a + b了1亿次.C++大约需要410毫秒,而JavaScript大约需要120毫秒.

我真的不知道为什么JavaScript在这种情况下运行如此之快.有谁能解释一下？

我用于JavaScript的代码是(使用Node.js运行):

(function() {
    var a = 3.1415926, b = 2.718;
    var i, j, d1, d2;
    for(j=0; j<10; j++) {
        d1 = new Date();
        for(i=0; i<100000000; i++) {
            a = a + b;
        }
        d2 = new Date();
        console.log("Time Cost:" + (d2.getTime() - d1.getTime()) + "ms");
    }
    console.log("a = " + a);
})();

C++的代码(由g ++编译)是:

#include <stdio.h>
#include <ctime>

int main() {
    double a = 3.1415926, b = 2.718;
    int i, …

我正在尝试逐步启用/禁用页面上的JavaScript(和CSS)效果 - 这取决于浏览器的速度/速度.

我特别想到的是低功耗移动设备和旧台式电脑 - 而不仅仅是IE6 :-)

有没有这种事情的例子？

衡量这一点的最佳方法是什么 - 会计事项,比如繁忙的CPU上的临时减速？

笔记:

• 我对浏览器/操作系统检测不感兴趣.
• 目前,我对带宽测量不感兴趣 - 只有浏览器/ CPU性能.
• 可能有趣的事情:
  • 基础JavaScript
  • DOM操作
  • DOM/CSS渲染
• 我想以尽可能少影响页面渲染速度的方式执行此操作.

顺便说一句:为了不混淆/激怒用户行为不一致 - 当然,这需要屏幕上的通知,以允许用户选择加入/退出整个性能调整过程.

[ 更新:我错过了一个相关问题:根据用户计算机的性能禁用JavaScript功能.谢谢Andrioid!]

我在 Intel i3-N305 3.8GHz 和 AMD Ryzen 7 3800X 3.9GHz PC 上运行了使用 gcc-13 ( https://godbolt.org/z/qq5WrE8qx )编译的相同二进制文件。此代码使用 VCL 库（https://github.com/vectorclass/version2）：

int loop_vc_nested(const array<uint8_t, H*W> &img, const array<Vec32uc, 8> &idx) {
  int sum = 0;
  Vec32uc vMax, iMax, vCurr, iCurr;

  for (int i=0; i<H*W; i+=W) {
    iMax.load(&idx[0]);
    vMax.load(&img[i]);

    for (int j=1; j<8; j++) {
      iCurr.load(&idx[j]);
      vCurr.load(&img[i+j*32]);
      iMax = select(vCurr > vMax, iCurr, iMax);
      vMax = max(vMax, vCurr);
    }

    Vec32uc vMaxAll{horizontal_max(vMax)};
    sum += iMax[horizontal_find_first(vMax == vMaxAll)];
  }

  return sum;
}

完整的基准源位于：https://github.com/pauljurczak/simd-benchmarks/blob/main/main-5-vcl-eve.cpp …

试验Ruby的Benchmark模块......

>> Benchmark.bm(7) { |b| b.report('Report:') { s = '' ; 10000.times { s += 'a' } }  }
             user     system      total        real
Report:  0.150000   0.010000   0.160000 (  0.156361)

"用户","系统"和"真实"的含义是什么？

Android文档中的"性能提示"部分有一个非常大胆的主张:

one()是比较快的.它将所有内容都拉到局部变量中,避免了查找.只有阵列长度才能提供性能优势.

它引用此代码段:

int len = localArray.length;

for (int i = 0; i < len; ++i) {
    sum += localArray[i].mSplat;
}

这让我感到很惊讶,因为localArray.length只是访问一个整数,如果你使用一个中间变量,你必须再次执行相同的步骤.我们真的在说一个只需要x代替的中间变量y.x更快吗？

我看了一下这个问题是关于同样的想法但是使用了一个arraylist及其后续的.size()方法.这里的共识似乎是没有区别,因为方法调用可能只是内联到整数访问(这正是我们在这里的场景).

所以我接受了字节码,看看是否可以告诉我任何事情.

给出以下源代码:

public void MethodOne() {
    int[] arr = new int[5];
    for (int i = 0; i < arr.length; i++) { }
}

public void MethodTwo() {
    int[] arr = new int[5];
    int len = arr.length;
    for (int i = 0; i < …