标签: microbenchmark

我试图使我的程序尽可能少服务器密集.使用双引号并包含变量或使用单引号和使用会更好吗？连接变量？

例如,

$string = 'Hello ' . $first_name;
$string_two = "Hello $first_name";

哪种方式会更快？我知道这是最小的,但我认为这将帮助我弄清楚PHP如何在内部工作.

在C中,puts(string);将打印string到stdout,然后是换行符.fputs(fileptr, string);,而另一方面,会写信string给fileptr没有结尾的新行.是否有任何函数fputs()添加换行符,或者我应该fprintf(fileptr, "%s\n", string);像我一直使用的那样坚持？

fputs()似乎比fprintf()对我更有效,因为它没有解析它的输入.我知道我也可以用

fputs(string, fileptr);
fputc('\n', fileptr);

但我想知道是否有办法用一个磁盘写入.

我试图找出如何puts()追加换行符(因为printf()实际上只是一个包装的vfprintf(stdout, ...),我认为同样可能拥有真正的puts()和fputs()),但我奇怪找不到puts()在glibc的源.

前一段时间,我问了一个关于堆栈溢出的问题,并展示了如何在C++中执行rdtsc操作码.我最近使用rdtsc创建了一个基准函数,如下所示:

inline unsigned long long rdtsc() {
  unsigned int lo, hi;
  asm volatile (
     "cpuid \n"
     "rdtsc" 
   : "=a"(lo), "=d"(hi) /* outputs */
   : "a"(0)             /* inputs */
   : "%ebx", "%ecx");     /* clobbers*/
  return ((unsigned long long)lo) | (((unsigned long long)hi) << 32);
}

typedef uint64_t (*FuncOneInt)(uint32_t n);
/**
     time a function that takes an integer parameter and returns a 64 bit number
     Since this is capable of timing in clock cycles, we won't have to do it a
     huge …

在此SO帖子中,在对各种解决方案进行基准测试时进行了讨论.请考虑以下代码

# global environment is empty - new session just started
# set up
set.seed(20181231)
n <- sample(10^3:10^4,10^3)
for_loop <- function(n) {
  out <- integer(length(n))
  for(k in 1:length(out)) {
    if((k %% 2) == 0){
      out[k] <- 0L
      next
    }
    out[k] <- 1L
    next
  }
  out
}
# benchmarking
res <- microbenchmark::microbenchmark(
  for_loop = {
    out <- integer(length(n))
    for(k in 1:length(out)) {
      if((k %% 2) == 0){
        out[k] <- 0L
        next
      }
      out[k] <- 1L
      next
    }
    out
  }, …

我一直在玩一些 x64 程序集和 XMM 寄存器来做一些浮点数学，我看到一些让我感到困惑的性能。

作为自学练习，我编写了一些 SSE 程序集来近似“sin”函数（使用泰勒级数），并在循环中从一些基本的 C++ 调用它以与标准库版本进行比较。代码如下，之后我粘贴了一些典型运行的输出。（我不是在寻找对代码或方法的批评，只是想了解性能数字）。

我不明白的是为什么使用“发布”构建，其中实际运行的程序集是相同的（我已经通过调试器进行了仔细检查），始终慢了大约 40 - 50 个周期。（取消对 LFENCE 指令的注释会为 Debug 和 Release 增加大约 100 个周期，因此增量保持不变）。作为一个额外的问题，为什么第一次迭代通常是数千次！！

我知道这些东西非常复杂，并且受到许多因素的微妙影响，但是作为潜在原因出现在我脑海中的一切都是没有意义的。

我已经在两次运行中检查了 MSCSR 标志，这在构建中也是相同的（默认值为 1f80h，它屏蔽了所有异常）。

知道什么会导致这种情况吗？我可以做哪些进一步的分析来更深层次地解决这个问题？

集会

_RDATA segment
    pi  real4 3.141592654
    rf3 real4 0.1666666667
    rf5 real4 0.008333333333
    rf7 real4 0.0001984126984
_RDATA ends


_TEXT segment

; float CalcSin(float rads, int* cycles)
CalcSin PROC
    ; "leaf" function - doesn't use the stack or any non-volatile registers
    mov r8, rdx                ; Save the 'cycles' pointer …

我做了一个测试，通过将它们的值打印到 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 多次。

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

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

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

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

日志打印是否足够好？

我试图弄清楚以下每个操作计算从 1 到 100 的累积和的速度有多快/慢。

install.package('microbenchmark')
library(microbenchmark)

#Method 1
cs_for = function(x) {
  for (i in x) {
    if (i == 1) {
      xc = x[i]
    } else {
      xc = c(xc, sum(x[1:i]))
    }
  }
  xc
}

cs_for(1:100)

# Method 2: with apply (3 lines)
cs_apply = function(x) {
  sapply(x, function(x) sum(1:x))
}

cs_apply(100)

# Method 3: 
cumsum (1:100)

microbenchmark(cs_for(1:100), cs_apply(100), cumsum(1:100))

我得到的输出如下：

Unit: nanoseconds
          expr   min     lq      mean   median     uq    max neval cld
 cs_for(1:100) 97702 100551 106129.05 102500.5 105151 …

阅读问题后为什么处理排序数组的速度比未排序数组快？ 我们曾尝试将变量设置为volatile(我预计,当我使用volatile时,它必须工作得更慢,但工作速度更快)这是我的代码没有volatile :(工作时间约为11秒)

import java.util.Arrays;
import java.util.Random;

public class GGGG {

public static void main(String[] args) {
    int arraySize = 32768;
    int data[];
    data = new int[arraySize];

    Random rnd = new Random(0);
    for (int c = 0; c < arraySize; ++c) {
        data[c] = rnd.nextInt() % 256;
    }

    Arrays.sort(data);

    long start = System.nanoTime();
    long sum = 0;

    for (int i = 0; i < 200000; ++i) {
        for (int c = 0; c < arraySize; ++c) {
            if (data[c] …

我在很多地方都读到 Scala 比 Java 快 20%。但是，我找不到对此的解释。我在 Java 方面有很好的经验，但从未真正在 Scala 上工作过，并且正在为我的下一个项目研究语言选择。
我的想法是，一旦程序被编译，JVM 就不会关心它是用 Scala 还是 Java 编写的。如果我错了，请纠正我。

编辑：是否有任何研究证明 Scala 编译器与 Java 编译器相比具有更好的编译优化？

PS：我不是在谈论编译时间，我只是在谈论运行时。

我多次注意到，微小的、看似无关的代码更改可以改变一段 Java 代码的性能特征，有时甚至是戏剧性的。

这发生在 JMH 和手动基准测试中。

例如，在这样的类中：

class Class<T> implements Interface {
    private final Type field;

    Class(ClassBuilder builder) {
        field = builder.getField();
    }

    @Override
    void method() { /* ... */ }
}

我做了这个代码更改：

class Class<T> implements Interface {
    private static Class<?> instance;

    private final Type field;

    Class(Builder builder) {
        instance = this;
        field = builder.getField();
    }

    @Override
    void method() { /* ... */ }
}

和性能发生了巨大变化。

这只是一个例子。在其他情况下，我注意到了同样的事情。

我无法确定是什么原因造成的。我在网上搜索，但没有找到任何信息。

对我来说，它看起来完全无法控制。也许这与编译后的代码在内存中的布局有关？

我不认为这是由于错误共享（见下文）。

我正在开发一个自旋锁：

class SpinLock {
    @Contended // Add compiler option: --add-exports …

我正在对从stringtoint和uint使用以下代码的解组进行基准测试：

package main

import (
    "strconv"
    "testing"
)

func BenchmarkUnmarshalInt(b *testing.B) {
    for i := 0; i < b.N; i++ {
        UnmarshalInt("123456")
    }
}

func BenchmarkUnmarshalUint(b *testing.B) {
    for i := 0; i < b.N; i++ {
        UnmarshalUint("123456")
    }
}

func UnmarshalInt(v string) int {
    i, _ := strconv.Atoi(v)
    return i
}

func UnmarshalUint(v string) uint {
    i, _ := strconv.ParseUint(v, 10, 64)
    return uint(i)
}

结果：

Running tool: C:\Go\bin\go.exe test -benchmem -run=^$ myBench/main …

我想研究最新的处理器与标准 RISC V 实现（RISC V 具有 5 级管道 - 提取、解码、内存、ALU、回写）有何不同，但无法找到我应该如何开始解决问题以找到当前处理器流水线的实现

我尝试参考 i7-4510U 文档的英特尔文档，但没有太大帮助