我有这个基准函数：
BenchmarkMyTest(b *testing.B) {
}
我只想运行这个函数而不运行所有其他测试，但该命令对我来说从来没有用过。
go test -bench='BenchmarkMyTest'
or
go test -run='BenchmarkMyTest'
在 Go 中运行单个基准测试函数的正确方法是什么？它说使用正则表达式，但我找不到任何文档。
谢谢，
我目前正在开展一个项目，我们考虑切换到 Redis 作为数据库。我们的数据性质非常简单，似乎适合 Redis。由于没有使用 Redis 的经验，我做了一个非常小的基准测试，将其与 PostgreSQL 的插入性能进行比较（这对我们来说很重要）。
我创建了一个 .sql 文件，其中包含 200000 个 INSERT 语句到一个简单的模式中(address [key], timestamp, value)。插入大约需要 6 秒。
对于 Redis，200000 条记录中的每条记录都是通过以下方式插入的：
HSET data:address timestamp <VALUE>
HSET data:address value <VALUE>
将所有内容转储到 Redistime redis-cli < insert_data.redis需要 16 秒。我意识到这个“基准”是非常基本的，但是我是否缺少一些让 PostgreSQL 脱颖而出的东西？我真的无法想象 Redis 在插入方面实际上更慢。
考虑下面的类，它实现了（基本上是为了 MCVE）小字符串优化（假设小尾数、64 位指针等）：
class String {
char* data_;
bool sso() const { return reinterpret_cast<uintptr_t>(data_) & 1; }
public:
String(const char * arg = "") {
auto len = strlen(arg);
if (len > 6) {
data_ = new char[len + 1];
memcpy(data_, arg, len + 1);
}
else {
data_ = reinterpret_cast<char*>((uintptr_t)1);
memcpy(reinterpret_cast<char*>(&data_) + 1, arg, len + 1);
}
}
~String() { if (sso() == false) delete data_; }
// ~String() { if (reinterpret_cast<uintptr_t>(data_) & 1 == 0) …我正在分析一个应用程序在运行 linux 的 x86-64 处理器上的执行时间。在开始对应用程序进行基准测试之前，我想确保禁用动态频率缩放和空闲状态。
$ cat /sys/devices/system/cpu/cpufreq/boost
0
这告诉我频率缩放（Intel 的 Turbo Boost 或 AMD 的 Turbo Core）被禁用。事实上，我们将其设置为恒定的 2GHz，这在下一个练习中很明显。
$ cpupower --cpu 0-63 idle-info
CPUidle driver: none
CPUidle governor: menu
analyzing CPU 0:
CPU 0: No idle states
analyzing CPU 1:
CPU 1: No idle states
analyzing CPU 2:
CPU 2: No idle states
...
因此，空闲状态被禁用。现在我确定可以干扰基准测试的两个“功能”都被禁用，我继续使用 cpupower 监视应用程序。
但是，当我运行我的应用程序来监控 C 状态时，我发现超过 99% 的时间都花在了 C0 状态，这应该是这种情况。但是，我也看到了一种称为 Cx 状态的东西，其中内核花费了 0.01 - 0.02% 的时间。
$ cpupower monitor -c ./my_app …我读到R在矩阵中使用列优先存储，这意味着附近列中的元素存储在连续块或类似的东西中。这让我想知道：是按行填充矩阵更快（byrow=TRUE在基本 R 函数中使用matrix()）还是先按列填充矩阵（使用默认值byrow=FALSE）然后使用转置它更快t()？
我尝试对其进行基准测试。
> microbenchmark(matrix(1, n, n, byrow=TRUE))
Unit: seconds
expr min lq mean median uq max neval
matrix(1, n, n, byrow = TRUE) 1.047379 1.071353 1.105468 1.081795 1.112995 1.628675 100
> microbenchmark(t(matrix(1, n, n)))
Unit: seconds
expr min lq mean median uq max neval
t(matrix(1, n, n)) 1.43931 1.536333 1.692572 1.61793 1.726244 3.070821 100
似乎按行填充矩阵更快！我错过了什么吗？我原以为这R只会做一些重新标记，t()但实际上比逐行填充矩阵要慢！
对此有解释吗？我很困惑。
在 ThomasIsCoding 的回答和对自己进行了几次基准测试之后，它看起来取决于行数和列数。
我已经尝试过基准测试，出于某种原因，当在 1M 元素的数组上尝试它们时，它们在0.3 秒内Mergesort排序并Quicksort花费了 1.3 秒。
我听说快速排序通常更快，因为它的内存管理，但如何解释这些结果？
如果这有什么不同，我正在运行 MacBook Pro。输入是一组从 0 到 127 的随机生成的整数。
代码在Java中：
归并排序：
static void mergesort(int arr[]) {
int n = arr.length;
if (n < 2)
return;
int mid = n / 2;
int left[] = new int[mid];
int right[] = new int[n - mid];
for (int i = 0; i < mid; i++)
left[i] = arr[i];
for (int i = mid; i < n; i++)
right[i - mid] = arr[i];
mergesort(left);
mergesort(right); …当尝试对特定方法进行基准测试时，关于创建了多少对象以及在该方法运行时它们占用了多少字节，在 Android 中可以这样做：
Debug.resetThreadAllocCount()
Debug.resetThreadAllocSize()
Debug.startAllocCounting()
benchmarkMethod()
Debug.stopAllocCounting()
var memoryAllocCount = Debug.getThreadAllocCount()
var memoryAllocSize = Debug.getThreadAllocSize()
我现在想对相同的方法进行基准测试，但在这些方法不可用的普通桌面应用程序上。我没有发现任何类似的东西，我尝试过的任何其他内存基准测试代码都没有提供一致的结果，就像上面的代码一样，每次运行相同的基准测试时都会给出完全相同的结果。
任何建议，最好只是代码将不胜感激，但是如果它能够执行我正在尝试做的任务，我也愿意尝试一些软件。
对以下内容进行基准测试：
#!/usr/bin/env stack
-- stack --resolver lts-16.2 script --package async --package criterion
import Control.Concurrent.Async (async, replicateConcurrently_)
import Control.Monad (replicateM_, void)
import Criterion.Main
main :: IO ()
main = defaultMain [
bgroup "tests" [ bench "sync" $ nfIO syncTest
, bench "async" $ nfIO asyncTest
]
]
syncTest :: IO ()
syncTest = replicateM_ 100000 dummy
asyncTest :: IO ()
asyncTest = replicateConcurrently_ 100000 dummy
dummy :: IO Int
dummy = return $ fib 10000000000
fib :: Int -> Int
fib …我在编程方面没有太多经验，但我知道一点 Python3，现在我正在迈出我学习 Pharo 的第一步。我仍然不熟悉面向对象编程或类浏览器，但我已经阅读了 ProfStef 教程，并且我正在 Playground 上玩小程序，以熟悉语法。
我好奇的第一件事是这两种语言在速度方面的比较，因为我在某处读到 Pharo 内置了 JIT 编译器。 所以我用两种语言写了一个异想天开的脚本，生成了 800 万个数字，过滤其中的1/3，对每个计算1/sqrt(x)，将结果相加，重复该过程一百次，每次稍微改变间隔，最后再将结果相加，并对整个过程进行计时. 不是一个合适的基准，只是一个获得数量级估计的练习，但我试图让两个版本尽可能相似。
Python 3 版本：
import time, math
mega = lambda n: sum([1/math.sqrt(1 + i + n) for i in range(8000000) if (i + 1) // 3 == 0])
start = time.time()
print(sum([mega(n + 1) for n in range(100)]))
stop = time.time() - start
print(stop)
Python 3.8.5 的结果（默认，2020 年 7 月 28 日，12:59:40）：
34.7701230607214
52.75216603279114
Pharo 8 版本：
| mega range start stop |.
range …我写了一个小基准，其中程序创建了 的 10 个8二维std::vector结构{float, float}，然后将它们的长度平方相加。
这是C++代码：
#include <iostream>
#include <chrono>
#include <vector>
#include <array>
#include <cmath>
using namespace std;
using namespace std::chrono;
const int COUNT = pow(10, 8);
class Vec {
public:
float x, y;
Vec() {}
Vec(float x, float y) : x(x), y(y) {}
float len() {
return x * x + y * y;
}
};
int main() {
vector <Vec> vecs;
for(int i = 0; i < COUNT; ++i) {
vecs.emplace_back(i …