标签: benchmarking

我想记录真实壁挂时间有多长.目前我这样做:

startTime = time.time()
someSQLOrSomething()
print "That took %.3f seconds" % (time.time() - startTime)

但是如果在SQL查询(或其他任何东西)运行时调整时间,则会失败(产生不正确的结果).

我不想只是对它进行基准测试.我想在实时应用程序中记录它,以便查看实时系统的趋势.

我想要像clock_gettime(CLOCK_MONOTONIC,...)这样的东西,但是在Python中.并且最好不必编写调用clock_gettime()的C模块.

我花了18个月的时间来掌握函数式编程,从学习OCaml开始,现在已经有几个星期的Haskell了.现在我想采取下一步并实现一些实际的应用程序:一个简单的实时地形编辑器.我写了很多实时地形渲染引擎,所以这是一个熟悉的主题.使用的递归算法和数据结构似乎非常适合功能实现.

由于这是一个实时应用程序,我自然而然地寻找我能得到的最佳性能.现在,与OCaml或F#相比,OCaml的一些(恕我直言,非常烦人)支持者反对Haskell的频率很慢.但根据计算机语言基准测试游戏 Haskell经常击败OCaml,如果只是相当小的分数 - 仍然存在问题,这个基准测试只需要非常具体的样本.

正确的做法当然是用两种语言实现程序并进行比较,但我根本不想做双重工作.

但也许其他人在OCaml和Haskell中做了类似的应用程序并提供了一些数据？

作为我研究在流中使用复杂过滤器或多个过滤器之间区别的一部分，我注意到Java 12的性能比Java 8慢。

这些奇怪的结果有什么解释吗？我在这里想念什么吗？

组态：

• Java 8

  • OpenJDK运行时环境（内部版本1.8.0_181-8u181-b13-2〜deb9u1-b13）
  • OpenJDK 64位服务器VM（内部版本25.181-b13，混合模式）

• Java 12

  • OpenJDK运行时环境（内部版本12 + 33）
  • OpenJDK 64位服务器VM（内部版本12 + 33，混合模式，共享）

• VM选项： -XX:+UseG1GC -server -Xmx1024m -Xms1024m

• CPU：8核

JMH吞吐量结果：

• 预热：10次迭代，每次1秒
• 测量：10次迭代，每次1秒
• 线程：1个线程，将同步迭代
• 单位：ops / s

码

流+复杂过滤器

public void complexFilter(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream()
                .filter(d -> d < Math.PI
                        && d > Math.E
                        && d != 3
                        && d != 2)
                .count();

        blackhole.consume(count);
    }

流+多个过滤器

public void multipleFilters(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream() …

我正在读Fedor Pikus 的这本书，他有一些非常非常有趣的例子，对我来说是一个惊喜。
特别是这个基准测试吸引了我，唯一的区别是在其中一个我们使用 || 在 if 和另一个中我们使用 |。

void BM_misspredict(benchmark::State& state)
{

    std::srand(1);
    const unsigned int N = 10000;;
    std::vector<unsigned long> v1(N), v2(N);
    std::vector<int> c1(N), c2(N);

    for (int i = 0; i < N; ++i) 
    {
        v1[i] = rand();
        v2[i] = rand();
        c1[i] = rand() & 0x1;
        c2[i] = !c1[i];
    }

    unsigned long* p1 = v1.data();
    unsigned long* p2 = v2.data();
    int* b1 = c1.data();
    int* b2 = c2.data();

    for (auto _ : state)
    {
        unsigned long a1 …

背景

在今天早上运行基准测试时,我和我的同事发现了一些关于C#代码与VB.NET代码性能的奇怪之处.

我们开始比较C#与Delphi Prism计算质数,发现Prism的速度提高了约30%.在生成IL时,我认为CodeGear优化代码更多(exe大约是C#的两倍,并且有各种不同的IL.)

我决定在VB.NET中编写一个测试,假设微软的编译器最终会为每种语言编写基本相同的IL.然而,结果更令人震惊:C#的代码运行速度比VB运行速度快三倍以上!

生成的IL是不同的,但并非极端如此,而且我不太善于阅读它以理解差异.

基准

我已经在下面列出了每个代码.在我的机器上,VB在大约6.36秒内找到了348513个素数.C#在21.76秒内找到相同数量的素数.

计算机规格和注释

• 英特尔酷睿2四核6600 @ 2.4Ghz

我在那里测试的每台机器在C#和VB.NET之间的基准测试结果上都有明显的差异.

两个控制台应用程序都是在发布模式下编译的,但是否则没有从Visual Studio 2008生成的默认值更改项目设置.

VB.NET代码

Imports System.Diagnostics

Module Module1

    Private temp As List(Of Int32)
    Private sw As Stopwatch
    Private totalSeconds As Double

    Sub Main()
        serialCalc()
    End Sub

    Private Sub serialCalc()
        temp = New List(Of Int32)()
        sw = Stopwatch.StartNew()
        For i As Int32 = 2 To 5000000
            testIfPrimeSerial(i)
        Next
        sw.Stop()
        totalSeconds = sw.Elapsed.TotalSeconds
        Console.WriteLine(String.Format("{0} seconds elapsed.", totalSeconds))
        Console.WriteLine(String.Format("{0} primes found.", temp.Count))
        Console.ReadKey() …

是否有一个简单的库来衡量执行部分C代码所需的时间？我想要的是:

int main(){
    benchmarkBegin(0);
    //Do work
    double elapsedMS = benchmarkEnd(0);

    benchmarkBegin(1)
    //Do some more work
    double elapsedMS2 = benchmarkEnd(1);

    double speedup = benchmarkSpeedup(elapsedMS, elapsedMS2); //Calculates relative speedup
}

如果图书馆允许你进行多次运行,平均它们并计算时间差异,这也会很棒!

我试图找出最快的矩阵乘法方法,尝试了3种不同的方法:

• 纯python实现:这里没有惊喜.
• Numpy实现使用 numpy.dot(a, b)
• 使用ctypesPython中的模块与C连接.

这是转换为共享库的C代码:

#include <stdio.h>
#include <stdlib.h>

void matmult(float* a, float* b, float* c, int n) {
    int i = 0;
    int j = 0;
    int k = 0;

    /*float* c = malloc(nay * sizeof(float));*/

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            int sub = 0;
            for (k = 0; k < n; k++) {
                sub = sub + a[i * n + …

我尝试计算Ackermann(4,1),不同语言/编译器之间的性能差异很大.以下是我的Core i7 3820QM,16G,Ubuntu 12.10 64bit的结果,

C:1.6s,gcc -O3 (gcc 4.7.2)

int ack(int m, int n) {
  if (m == 0) return n+1;
  if (n == 0) return ack(m-1, 1);
  return ack(m-1, ack(m, n-1));
}

int main() {
  printf("%d\n", ack(4,1));
  return 0;
}

OCaml:3.6s,ocamlopt (与ocaml 3.12.1)

let rec ack = function
  | 0,n -> n+1
  | m,0 -> ack (m-1, 1)
  | m,n -> ack (m-1, ack (m, n-1))
in print_int (ack (4, 1)) …

我对此很好奇.

我想检查哪个函数更快,所以我创建了一个小代码,我执行了很多次.

public static void main(String[] args) {

        long ts;
        String c = "sgfrt34tdfg34";

        ts = System.currentTimeMillis();
        for (int k = 0; k < 10000000; k++) {
            c.getBytes();
        }
        System.out.println("t1->" + (System.currentTimeMillis() - ts));

        ts = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            Bytes.toBytes(c);
        }
        System.out.println("t2->" + (System.currentTimeMillis() - ts));

    }

"第二个"循环更快,因此,我认为hadoop中的Bytes类比String类中的函数更快.然后,我改变了循环的顺序,然后c.getBytes()变得更快.我执行了很多次,我的结论是,我不知道为什么,但是在第一个代码执行后我的VM中发生了一些事情,以便第二个循环的结果变得更快.

为什么:内存:在sqlite中这么慢？

我一直试图看看使用内存中的sqlite和基于磁盘的sqlite是否有任何性能改进.基本上我想交换启动时间和内存来获得非常快速的查询,这些查询在应用程序过程中没有遇到磁盘.

但是,以下基准测试只能提高1.5倍的速度.在这里,我正在生成1M行随机数据并将其加载到同一个表的磁盘和基于内存的版本中.然后我在两个dbs上运行随机查询,返回大小约为300k的集合.我预计基于内存的版本要快得多,但如上所述,我只能获得1.5倍的加速.

我尝试了几种其他大小的dbs和查询集; 内存:优势也似乎上升为行的分贝数增加了.我不确定为什么优势如此之小,尽管我有一些假设:

• 使用的表格不够大(在行中):内存:一个巨大的赢家
• 更多的连接/表将使:内存:优势更明显
• 在连接或操作系统级别进行某种缓存,以便以某种方式访问​​先前的结果,从而破坏基准测试
• 有一种隐藏的磁盘访问正在进行,我没有看到(我还没有尝试过lsof,但我确实关闭了PRAGMAs用于日记)

我在这里做错了吗？关于原因的任何想法:内存:不会产生几乎即时的查找？这是基准:

==> sqlite_memory_vs_disk_benchmark.py <==

#!/usr/bin/env python
"""Attempt to see whether :memory: offers significant performance benefits.

"""
import os
import time
import sqlite3
import numpy as np

def load_mat(conn,mat):
    c = conn.cursor()

    #Try to avoid hitting disk, trading safety for speed.
    #http://stackoverflow.com/questions/304393
    c.execute('PRAGMA temp_store=MEMORY;')
    c.execute('PRAGMA journal_mode=MEMORY;')

    # Make a demo table
    c.execute('create table if not exists demo (id1 int, id2 int, val real);')
    c.execute('create index id1_index on demo …