标签: benchmarking

对不起,这是一个很长的问题,但我只是在分析这个问题时解释我的思路.最后的问题.

我已经了解了测量代码运行时间的方法.它运行多次以获得平均运行时间来计算每次运行的差异,并获得更好地利用缓存的时间.

为了测量某人的运行时间,我在多次修改后想出了这段代码.

最后,我最终得到了这个代码,它产生了我打算捕获的结果,而没有给出误导性的数字:

// implementation C
static void Test<T>(string testName, Func<T> test, int iterations = 1000000)
{
    Console.WriteLine(testName);
    Console.WriteLine("Iterations: {0}", iterations);
    var results = Enumerable.Repeat(0, iterations).Select(i => new System.Diagnostics.Stopwatch()).ToList();
    var timer = System.Diagnostics.Stopwatch.StartNew();
    for (int i = 0; i < results.Count; i++)
    {
        results[i].Start();
        test();
        results[i].Stop();
    }
    timer.Stop();
    Console.WriteLine("Time(ms): {0,3}/{1,10}/{2,8} ({3,10})", results.Min(t => t.ElapsedMilliseconds), results.Average(t => t.ElapsedMilliseconds), results.Max(t => t.ElapsedMilliseconds), timer.ElapsedMilliseconds);
    Console.WriteLine("Ticks:    {0,3}/{1,10}/{2,8} ({3,10})", results.Min(t => t.ElapsedTicks), results.Average(t => t.ElapsedTicks), results.Max(t => t.ElapsedTicks), timer.ElapsedTicks);
    Console.WriteLine();
}

在我看到的测量运行时间的所有代码中,它们通常采用以下形式: …

我可以使用mysqlslap来测试特定的数据库/表吗？或者只是mysqlslap数据库？

谢谢

这个问题是关于访问数组和切片元素的速度,而不是关于将它们作为参数传递给函数的效率.

在大多数情况下,我希望数组比切片更快,因为切片是描述数组的连续部分的数据结构,因此在访问切片的元素时可能会涉及额外的步骤(间接地是其底层数组的元素) .

所以我写了一个小测试来测试一批简单的操作.有4个基准函数,前2个测试全局切片和全局数组,另外2个测试局部切片和本地数组:

var gs = make([]byte, 1000) // Global slice
var ga [1000]byte           // Global array

func BenchmarkSliceGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for j, v := range gs {
            gs[j]++; gs[j] = gs[j] + v + 10; gs[j] += v
        }
    }
}

func BenchmarkArrayGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for j, v …

我试图对Scotty进行测试,以测试网络I/O效率和整体吞吐量.

为此,我设置了两个用Haskell编写的本地服务器.一个不做任何事情而只是充当API的人.

代码相同

{-# LANGUAGE OverloadedStrings #-}


import Web.Scotty

import Network.Wai.Middleware.RequestLogger 

import Control.Monad
import Data.Text
import Control.Monad.Trans
import Data.ByteString
import Network.HTTP.Types (status302)
import Data.Time.Clock
import Data.Text.Lazy.Encoding (decodeUtf8)
import Control.Concurrent
import Network.HTTP.Conduit
import Network.Connection (TLSSettings (..))
import Network.HTTP.Client
import Network
main = do 
  scotty 4001 $ do
    middleware logStdoutDev
    get "/dummy_api" $ do
        text $ "dummy response"

我写了另一个调用此服务器并返回响应的服务器.

{-# LANGUAGE OverloadedStrings #-}


import Web.Scotty

import Network.Wai.Middleware.RequestLogger 

import Control.Monad
import Control.Monad.Trans
import qualified Data.Text.Internal.Lazy as LT
import Data.ByteString
import Network.HTTP.Types (status302)
import …

我看到术语软件基准测试和分析有时可以互换,但据我的理解,这是一个微妙的差异.

两者都是按时间连接的.但是,虽然基准测试主要是确定可以与其他应用程序进行比较的特定速度分数,但分析可以为您提供有关应用程序在大部分时间(或周期数)上花费的确切信息.

对我来说,它总是如下:集成测试是基准测试和单元测试对应的分析测试的对应物.但微基准测试如何适用于此？

有人在这里说:

分析和基准测试是相同硬币的另一面,分析可帮助您缩小到最有用的优化位置,基准测试可让您轻松隔离优化并对它们进行交叉比较.

另一个人在这里谈到分析:

分析在不同时间意味着不同的东西.有时它意味着衡量绩效.有时它意味着诊断内存泄漏.有时它意味着可以了解多线程或其他低级别活动.

那么,这些技术在概念上是不同的还是不是那种黑白？

我正在比较 Julia 和 C++ 之间的性能。然后我发现 Julia 中的快速排序要快得多（甚至比 C++ 还要快），尤其是当数组的大小非常大时。

任何人都可以解释原因吗？

快速排序文件

include("../dimension.jl")
function execute()  
    n = getDimension()
    print(stderr, "Julia,quickSort_optim,$n,");  # use default delimiter
    arr = zeros(Int32, n)
    for i = 1:n
        arr[i] = (777*(i-1)) % 10000
    end
    if n > 0
        sort!(arr; alg=QuickSort)
    end
end

# executing ...
execute()

quickSort_boost.cpp

#include "dimension.h" 
#include <boost/lambda/lambda.hpp>
#include <boost/sort/pdqsort/pdqsort.hpp>
#include <iostream>
#include <iterator>
#include <algorithm>
 
using namespace std;
using namespace boost::sort; 

int main()
{
    int n = getDimension();
    cerr << "C++,quickSort_boost," << n …

我需要类似套接字的本地IPC.我在Windows上使用了命名管道和重叠IO,我想将应用程序重写为boost :: ASIO,以便它也可以使用UNIX域套接字.

我最近审查了libevent库的部分内容,我知道它只支持1.4版本中的socket()和select().由于重叠的IO是非常有效的,因此将其排除显然是一个不可接受的特性,它在版本2(在alpha中)中得到了解决.次优执行的另一个例子是使用的红黑树与PRIO队列为其超时逻辑不客气沿线某处.

有没有人对boost vs libevent/libev的性能特征有任何意见.它在某些平台上是否有任何明显的不良特征？我对这个问题的目标是,除非我绝对必须,否则我不想对ASIO库进行操作.我想知道boost :: asio是否以最佳方式使用最优的OS原语.

我一直在寻找可以帮助我进行负载测试和基准测试的工具.我发现夫妇喜欢:https://github.com/wg/wrk,http://www.joedog.org/siege-home/,https://github.com/rakyll/boom.我想知道是否有人对这些工具有任何经验,并且对这些工具有任何反馈优点和缺点.我的负载压力将包括使用DELETE,PUT,GET,POST ...标头的不同测试用例

谢谢

如果IIUC每个fork创建一个单独的虚拟机,原因是每个虚拟机实例可能在JIT指令中略有不同的情况下运行？

我也很好奇时间属性在下面的注释中做了什么:

@Warmup(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)

TIA,Ole

虽然我知道尾部递归优化是非Pythonic的,但我想到了一个快速入侵这里的问题,一旦我准备发布就删除了.

由于1000个堆栈限制,深度递归算法在Python中不可用.但有时通过解决方案对初步想法很有帮助.由于函数是Python中的第一类,我使用返回有效函数和下一个值.然后循环调用该进程,直到完成单个调用.我敢肯定这不是新的.

我发现有趣的是,我期望来回传递函数的额外开销使得这比正常递归慢.在我的粗略测试期间,我发现它需要30-50%的正常递归时间.(允许LONG递归的额外好处.)

这是我正在运行的代码:

from contextlib import contextmanager
import time

# Timing code from StackOverflow most likely.
@contextmanager
def time_block(label):
    start = time.clock()
    try:
        yield
    finally:
        end = time.clock()
        print ('{} : {}'.format(label, end - start))


# Purely Recursive Function
def find_zero(num):
    if num == 0:
        return num
    return find_zero(num - 1)


# Function that returns tuple of [method], [call value]
def find_zero_tail(num):
    if num == 0:
        return None, num
    return find_zero_tail, num - 1


# Iterative recurser
def tail_optimize(method, …