标签: benchmarking

IA-32,IA-64上哪个算术指令集操作最慢,速度最快？有排名吗？基准？

我正面临 ap​​ache 基准测试文件的一个奇怪问题。

我需要强调一个处理文件上传的功能。所以，我用谷歌搜索，找到了一篇描述如何正确构建帖子文件的帖子。其内容如下：

--1234567
Content-Disposition: form-data; name="user_id"

3
--1234567
Content-Disposition: form-data; name="file"; filename="cf_login.png"
Content-Type: image/png

[base64 encoded file content]
--1234567--

ab 线是这样的：

$ ab -c 1 -n 5 -v 4 -T 'multipart/form-data; boundary=1234567' -p post_file.txt http://localhost:3000/files

当 ab 发出请求时，生成的标头如下：

INFO: POST header == 
---
POST /files.json/ HTTP/1.0
Content-length: 229
Content-type: multipart/form-data; boundary=simpleboundary
Host: localhost:3000
User-Agent: ApacheBench/2.3
Accept: */*


---
LOG: header received:
HTTP/1.1 500 Internal Server Error 
Content-Type: text/html; charset=utf-8
Content-Length: 13265
X-Request-Id: 9ad57d19cd71886a1bb817d00fac651b
X-Runtime: 0.015504
Server: WEBrick/1.3.1 (Ruby/1.9.3/2012-04-20) …

我有一个用于处理数组分配的类.我的课很简单,定义如下:

DimArray.hpp:

#ifndef DIMARRAY_HPP_INCLUDED
#define DIMARRAY_HPP_INCLUDED

#include <vector>

template<typename T>
class DimArray
{
    private:
        int Width, Height;
        std::vector<T> Data;

    public:
        DimArray(int Width, int Height);
        DimArray(T* Data, int Width, int Height);
        DimArray(T** Data, int Width, int Height);

        DimArray(const DimArray &da);
        DimArray(DimArray &&da);

        inline int size() {return Width * Height;}
        inline int size() const {return Width * Height;}

        inline int width() {return Width;}
        inline int width() const {return Width;}

        inline int height() {return Height;}
        inline int height() const {return Height;}

        inline T* …

我刚刚了解了 JMH 微基准测试框架（http://openjdk.java.net/projects/code-tools/jmh/）。我只是想知道他们是如何实现 @CompileControl 注释功能的。从源代码中，他们在单个文本文件中简单地向编译器编写了一系列指令（提示）。

我只是想知道是否可以找到一些关于底层机制的附加文档，它仅适用于 OpenJDK。

我正在尝试从Rust哈希映射中获取密钥.我有以下基准:

#[bench]
fn rust_get(b: &mut Bencher) {
    let (hash, keys) =
        get_random_hash::<HashMap<String, usize>>(&HashMap::with_capacity, &rust_insert_fn);
    let mut keys = test::black_box(keys);
    b.iter(|| {
        for k in keys.drain(..) {
            hash.get(&k);
        }
    });
}

其中get_random_hash定义为:

fn get_random_hash<T>(
    new: &Fn(usize) -> T,
    insert: &Fn(&mut T, String, usize) -> (),
) -> (T, Vec<String>) {
    let mut keys = Vec::with_capacity(HASH_SIZE);
    let mut hash = new(HASH_CAPACITY);
    for i in 0..HASH_SIZE {
        let k: String = format!("{}", Uuid::new_v4());
        keys.push(k.clone());
        insert(&mut hash, k, i);
    }
    return (hash, …

一个以前的SO问题提出了有关这成语是在执行efficency方面更好的时间问题:

[ (var := exp) > 0 ] whileTrue: [ ... ]

与

[ var := exp. 
  var > 0 ] whileTrue: [ ... ]

直观地看,第一种形式似乎在执行期间更有效,因为它节省了一个额外的声明(第二种形式).在大多数Smalltalks中都是如此吗？

试着用两个愚蠢的基准测试:

| var acc |
var := 10000.
[ [ (var := var / 2) < 0  ] whileTrue: [ acc := acc + 1 ] ] bench.

| var acc |
var := 10000.
[ [ var := var / 2. var < 0  ] whileTrue: [ acc := acc + …

我做了一个测试，通过将它们的值打印到 CLI 中来查看访问数组元素和单个对象之间的差异：

#include <iostream>
#include <chrono>
#include <iomanip>

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};

    int v1 = 1;
    int v2 = 2;
    int v3 = 3;
    int v4 = 4;
    int v5 = 5;
    int v6 = 6;
    int v7 = 7;
    int v8 = 8;
    int v9 = 9;
    int v10 = 10;

    std::cout << "Array output:" << std::endl << std::endl;

    auto t_start1 = std::chrono::high_resolution_clock::now();

    std::cout << "1. value: " << a[0] << std::endl;
    std::cout << "2. …

我正在评估我的项目的网络+渲染工作负载。

程序连续运行一个主循环：

while (true) {
   doSomething()
   drawSomething()
   doSomething2()
   sendSomething()
}

主循环每秒运行 60 多次。

我想查看性能故障，每个程序需要多少时间。

我担心的是，如果我打印每个程序的每个入口和出口的时间间隔，

这会导致巨大的性能开销。

我很好奇什么是衡量性能的惯用方法。

日志打印是否足够好？

这个要点是我写的一个小型基准测试，用于比较JS中深度为 1 的扁平数组的 4 种替代方案的性能 （代码可以按原样复制到谷歌控制台）。如果我没有遗漏任何东西，那么本机 Array.prototype.flat 迄今为止的性能最差 - 比任何替代品慢 30-50 倍。

更新：我在jsperf上创建了一个基准。

应该注意的是，该基准测试中的第 4 次实现始终是性能最高的 - 通常实现 70 倍的性能。该代码在 node v12 和 Chrome 控制台中进行了多次测试。

这个结果在一个大的子集中最为突出 - 请参阅下面测试的最后 2 个数组。考虑到规范和似乎完全遵循规范的V8 实现，这个结果非常令人惊讶。我的 C++ 知识不存在，因为我对 V8 兔子洞很熟悉，但在我看来，鉴于递归定义，一旦我们到达最终深度子数组，就不会对该子数组调用进行进一步的递归调用（标志当递减的深度达到 0 时，shouldFlatten 为假，即最终的子级别）并且添加到扁平结果包括迭代循环每个子元素，以及对该方法的简单调用。因此，我看不出为什么 a.flat 应该在性能上受到如此大的影响。

我想也许在原生公寓中结果的大小没有预先分配的事实可能解释了这种差异。此基准测试中的第二个实现（未预先分配）表明，仅凭这一点无法解释差异 - 它的性能仍然是原生 flat 的 5-10 倍。这可能是什么原因？

已测试的实现（代码中的顺序相同，存储在 implementations 数组中 - 我写的两个在代码片段的末尾）：

1. 我自己的展平实现包括预先分配最终展平的长度（从而避免所有重新分配的大小）。原谅命令式风格的代码，我是为了最大的性能。
2. 最简单的实现，循环遍历每个子数组并推入最终数组。（因此冒着许多大小重新分配的风险）。
3. Array.prototype.flat（原生平面）
4. [ ].concat(...arr)（=展开数组，然后将结果连接在一起。这是一种实现深度=1 展平的流行方法）。

测试的数组（代码中的顺序相同，存储在 benchmarks 对象中）：

1. 1000 个子数组，每个子数组 10 个元素。（共10人）
2. 10 个子数组，每个子数组 …

我在Uber 的风格指南上读到，一个人最多应该使用 1 的通道长度。

虽然我很清楚使用 100 或 1000 的通道大小是非常糟糕的做法，但我想知道为什么通道大小为 10 不被视为有效选项。我错过了一些部分来得出正确的结论。

在下面，您可以遵循由一些基准测试支持的我的论点（和反论点）。

我知道，如果您负责从该通道写入或读取的两个 go-routines 将在顺序写入或读取到/从通道之间被其他一些 IO 操作中断，则预计不会从更高的通道获得收益缓冲，我同意 1 是最好的选择。

但是，可以说，除了由通道写入/读取引起的隐式锁定和解锁之外，不需要其他重要的 go-routine 切换。那么我总结如下：

在使用大小为 1 和 10 的通道缓冲区（GR = go-routine）的通道上处理 100 个值时，考虑上下文切换的数量

• 缓冲区=1：（GR1 插入 1 个值，GR2 读取 1 个值）X 100 ~ 200 个 go-routine 切换
• Buffer=10：（GR1 插入 10 个值，GR2 读取 10 个值）X 10 ~ 20 个 go-routine 开关

我做了一些基准测试来证明这实际上速度更快：

package main

import (
    "testing"
)

type a struct {
    b [100]int64
}

func BenchmarkBuffer1(b *testing.B) {
    count …