标签: benchmarking

问题设置简介

我在做一些涉及基准- ~A和A==0一double array with no NaNs,两者都转换A为逻辑阵列,所有zeros被转换为true值和休息被设置为false值.

对于基准测试,我使用了三组输入数据 -

• 从小到小的数据 - 15:5:100
• 中小型数据 - 50:40:1000
• 中型到大型数据 - 200:400:3800

输入是使用A = round(rand(N)*20),其中N是从size数组中获取的参数.因此,N会从变化15 to 100 with stepsize of 5为所述第一组和类似地对于第二和第三组.请注意,我将datasize定义为N,因此元素的数量将是datasize ^ 2或N ^ 2.

基准代码

N_arr = 15:5:100; %// for very small to small sized input array
N_arr = 50:40:1000; %// for small to medium sized input array
N_arr = 200:400:3800; %// for medium …

我正在对Java UDP客户端进行基准测试,该客户端以尽可能快的速度连续发送具有100字节有效负载的数据报.它是使用实现的java.nio.*.测试表明,它能够实现每秒220k数据报的稳定吞吐量.我没有测试服务器; 客户端只是将数据报发送到localhost上的一些未使用的端口.

我决定在Node.js中运行相同的测试来比较这两种技术,看到Node.js的执行速度比Java快10倍,我感到非常难过.让我带您浏览我的代码.

首先,我使用Node.js的dgram模块创建一个UDP套接字:

var client = require('dgram').createSocket("udp4");

然后我创建一个使用该套接字发送数据报的函数:

function sendOne() {
    client.send(message, 0, message.length, SERVER_PORT, SERVER_ADDRESS, onSend);
}

该变量message是在应用程序启动时从包含一百个字符的字符串创建的缓冲区:

var message = new Buffer(/* string with 100 chars */);

该函数onSend只增加一个变量,该变量保存到目前为止发送了多少数据报.接下来我有不断调用一个函数sendOne()使用setImmediate():

function sendForever() {
    sendOne();
    setImmediate(sendForever);
} 

最初我试图使用,process.nextTick(sendForever)但我发现它总是把自己放在事件队列的顶端,甚至在IO事件之前,正如文档所说:

它在事件循环的后续滴答中触发任何其他I/O事件(包括定时器)之前运行.

这可以防止发送 IO事件发生,就像每次打勾时nextTick一直放在sendForever队列的尖端一样.队列随着未读IO事件而增长,直到它使Node.js崩溃:

fish: Job 1, 'node client' terminated by signal SIGSEGV (Address boundary …

TLDR：

numpy.cos()在特定数字上（例如24000.0），其工作时间延长了30％。加一个小增量（+0.01）可使numpy.cos()照常工作。

我不知道为什么。

在与一起工作时，我偶然发现了一个奇怪的问题numpy。我正在检查缓存工作，并意外制作了错误的图形- numpy.cos(X)时间取决于时间X。这是我修改后的代码（从我的Jupyter笔记本复制）：

import numpy as np
import timeit
st = 'import numpy as np'
cmp = []
cmp_list = []
left = 0
right = 50000
step = 1000
# Loop for additional average smoothing
for _ in range(10):
    cmp_list = []
    # Calculate np.cos depending on its argument
    for i in range(left, right, step):
        s=(timeit.timeit('np.cos({})'.format(i), number=15000, setup=st))
        cmp_list.append(int(s*1000)/1000)
    cmp.append(cmp_list)

# Calculate average times
av=[np.average([cmp[i][j] for i in range(len(cmp))]) …

我想知道如何基准测试php/mysql网站.

我们有一个网络应用程序几乎已经完成并准备上线,我们知道有多少人将在几年内使用它,但绝对不知道普通用户需要多少带宽,他们燃烧了多少时间我们需要确定要购买的正确服务器.

是否有服务器端linux可以监控每个用户的这些统计信息？那么我们就可以获取这些数据并进行推断呢？

如果我对此完全出错,请告诉我,但我相信这是新网络应用的常见活动.

编辑:我可能要求提供不正确的信息.我们可以看到数据库查询需要多长时间以及加载页面所需的时间,但不知道服务器上放置了什么负载.我问的问题是,我们可以同时处理100个用户...... 1000？命中1M用户需要什么类型的服务器要求.等等.

谢谢你的帮助.

我的迷你基准:

import java.math.*;
import java.util.*;
import java.io.*;
public class c
{
    static Random rnd = new Random();
    public static String addDigits(String a, int n)
    {
        if(a==null) return null;
        if(n<=0) return a;
        for(int i=0; i<n; i++)
            a+=rnd.nextInt(10);
        return a;
    }
    public static void main(String[] args) throws IOException
    {
        int n = 10000; \\number of iterations
        int k = 10;    \\number of digits added at each iteration

        BigInteger a;
        BigInteger b;

        String as = "";
        String bs = "";
        as += rnd.nextInt(9)+1; …

我想了解Java对连续循环做了什么样的优化.更确切地说,我正在尝试检查是否执行了循环融合.从理论上讲,我期待这种优化不会自动完成,并且期望确认融合版本比具有两个循环的版本更快.

但是,在运行基准测试之后,结果显示两个独立(和连续)循环比完成所有工作的单个循环更快.

我已经尝试使用JMH创建基准测试并获得相同的结果.

我使用了该javap命令,它显示生成的具有两个循环的源文件的字节码实际上对应于正在执行的两个循环(没有循环展开或执行其他优化).

正在测量的代码BenchmarkMultipleLoops.java:

private void work() {
        List<Capsule> intermediate = new ArrayList<>();
        List<String> res = new ArrayList<>();
        int totalLength = 0;

        for (Capsule c : caps) {
            if(c.getNumber() > 100000000){
                intermediate.add(c);
            }
        }

        for (Capsule c : intermediate) {
            String s = "new_word" + c.getNumber();
            res.add(s);
        }

        //Loop to assure the end result (res) is used for something
        for(String s : res){
            totalLength += s.length();
        }

        System.out.println(totalLength);
    }

正在测量的代码BenchmarkSingleLoop.java:

private void work(){ …

在我将项目升级到.NET 4.0(使用VS2010)后,我意识到它们运行速度比在.NET 2.0(VS2008)中慢.所以我决定使用各种Target Frameworks对VS2008和VS2010中的简单控制台应用程序进行基准测试:

using System;
using System.Diagnostics;
using System.Reflection;

namespace RuntimePerfTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Assembly.GetCallingAssembly().ImageRuntimeVersion);
            Stopwatch sw = new Stopwatch();

            while (true)
            {
                sw.Reset();
                sw.Start();

                for (int i = 0; i < 1000000000; i++)
                {

                }

                TimeSpan elapsed = sw.Elapsed;
                Console.WriteLine(elapsed);
            }
        }
    }
}

结果如下:

• VS2008
  • 目标框架2.0:约0.25秒
  • 目标框架3.0:~0.25秒
  • 目标框架3.5:~0.25秒
• VS2010
  • 目标框架2.0:约3.8秒
  • 目标框架3.0:约3.8秒
  • 目标框架3.5:~1.51秒
  • Target Framework 3.5客户端配置文件:~3.8秒
  • 目标框架4.0:~1.01秒
  • Target Framework 4.0客户端配置文件:~1.01秒

我的初步结论显然是使用VS2008编译的程序比使用VS2010编译的程序运行得更快.

任何人都可以解释VS2008和VS2010之间的性能变化吗？在VS2010内部的不同目标框架之间？

我在这里读了一篇关于Stack Overflow的评论,在更改列表时进行切片分配的内存效率更高.例如,

a[:] = [i + 6 for i in a]

应该比内存更有效

a = [i + 6 for i in a]

因为前者替换现有列表中的元素,而后者创建一个新列表并重新绑定a到该新列表,将旧内容留a在内存中,直到它可以被垃圾收集.对速度进行基准测试,后者稍快一些:

$ python -mtimeit -s 'a = [1, 2, 3]' 'a[:] = [i + 6 for i in a]'
1000000 loops, best of 3: 1.53 usec per loop
$ python -mtimeit -s 'a = [1, 2, 3]' 'a = [i + 6 for i in a]'
1000000 loops, best of 3: 1.37 usec per loop …

我已经阅读了这个解决方案 tic(), toc() functions

tic <- function(gcFirst = TRUE, type=c("elapsed", "user.self", "sys.self"))
{
   type <- match.arg(type)
   assign(".type", type, envir=baseenv())
   if(gcFirst) gc(FALSE)
   tic <- proc.time()[type]         
   assign(".tic", tic, envir=baseenv())
   invisible(tic)
}

toc <- function()
{
   type <- get(".type", envir=baseenv())
   toc <- proc.time()[type]
   tic <- get(".tic", envir=baseenv())
   print(toc - tic)
   invisible(toc)
}




tic();
-----code----
toc();


elapsed 
   0.15 

但我想在几毫秒内获得很多精度？

我也在用这个

ptm <- proc.time()
---code
proc.time() - ptm

得到这个

   user  system elapsed 
   1.55    0.25    1.84 

如何获得更多小数或更精确？

有人可以解释为什么JMH说返回1比返回0快吗？

这是基准代码.

import org.openjdk.jmh.annotations.*;

import java.util.concurrent.TimeUnit;

@State(Scope.Thread)
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 3, jvmArgsAppend = {"-server", "-disablesystemassertions"})
public class ZeroVsOneBenchmark {

    @Benchmark
    @Warmup(iterations = 3, time = 2, timeUnit = TimeUnit.SECONDS)
    public int zero() {
        return 0;
    }

    @Benchmark
    @Warmup(iterations = 3, time = 2, timeUnit = TimeUnit.SECONDS)
    public int one() {
        return 1;
    }
}

结果如下:

# Run complete. Total time: 00:03:05

Benchmark                       Mode   Samples        Score  Score error    Units
c.m.ZeroVsOneBenchmark.one     thrpt        60  1680674.502    24113.014   ops/ms
c.m.ZeroVsOneBenchmark.zero    thrpt        60   735975.568    14779.380 …