标签: benchmarking

我有问题因为我真的不知道如何测试我的代码和sql(mysql)以查看SQL查询和PHP函数/代码运行多长时间.

有没有人知道我在哪里可以找到这些工具？

我正在寻找一些工具来改进我的Delphi开发.而我找不到任何免费项目的工具是一个基准工具.

有人对某些项目有些打击？

今天要检查我必须集中优化的地方,我使用样本分析,但这还不够我必须提供花费更多时间过剩的函数,而不仅仅是顶级调用函数.

TKS

控制器对模型进行几次调用,然后将一些数据返回给视图.遗憾的是,这个视图(这不是我的错),包含大量的内联查询和对模型的更多调用,是的,我知道.无论如何,我的任务是优化这个非常慢的页面,我试图弄清楚我怎么能分辨出哪些东西占用的时间最多.我只是将一个计时器放在页面所做的每个"事物"的开始和结束处,然后将它们输出到带有行号或其他内容的日志中.但不确定最准确的方法是什么.

//in controller
StartTimer();
var something = model.something.getsomething(someID);
StopTimerAndLog(3); //line number

<!-- in view -->
<%StartTimer();
var something = model.somethingelse.getanotherthing(someotherID);
StopTimerAndLog(2);%>

等等等等...

那么问题仍然是关于使用什么时间机制,我敢肯定必须有一个问题.但我不知道我的情况是否有任何独特之处......任何想法？

我用Java编写了一个(非常简单的)基准测试程序.它只是将double值增加到指定值并占用时间.

当我在我的6核桌面上使用这个单线程或少量线程(最多100个)时,基准测试会返回合理且可重复的结果.

但是当我使用例如1200个线程时,平均多核持续时间明显低于单个核心持续时间(大约10倍或更多).无论我使用了多少线程,我都确保增量的总量是相同的.

为什么性能会随着线程的增加而下降呢？有没有办法解决这个问题？

我发布了我的来源,但我认为没有问题.

Benchmark.java:

package sibbo.benchmark;

import java.text.DecimalFormat;
import java.util.LinkedList;
import java.util.List;

public class Benchmark implements TestFinishedListener {
            private static final double TARGET = 1e10;
    private static final int THREAD_MULTIPLICATOR = 2;

    public static void main(String[] args) throws InterruptedException {
        Benchmark b = new Benchmark(TARGET);
        b.start();
    }

    private int coreCount;
    private List<Worker> workers = new LinkedList<>();
    private List<Worker> finishedWorkers = new LinkedList<>();
    private double target;

    public Benchmark(double target) {
        this.target = target;
        getSystemInfos();
        printInfos();
    }

    private void getSystemInfos() …

在看到这个问题,有关大熊猫复制SQL选择语句类似的行为,我说这个答案显示,可以缩短在给出的详细的语法两种方式接受的答案这个问题.

在使用它们之后,我的两个较短的语法方法明显变慢,我希望有人可以解释原因

您可以假设下面使用的任何函数都来自Pandas,IPython或上面链接的问题和答案.

import pandas
import numpy as np
N = 100000
df = pandas.DataFrame(np.round(np.random.rand(N,5)*10))

def pandas_select(dataframe, select_dict):
    inds = dataframe.apply(lambda x: reduce(lambda v1,v2: v1 and v2,
                           [elem[0](x[key], elem[1])
                           for key,elem in select_dict.iteritems()]), axis=1)
    return dataframe[inds]



%timeit _ = df[(df[1]==3) & (df[2]==2) & (df[4]==5)]
%timeit _ = df[df.apply(lambda x: (x[1]==3) & (x[2]==2) & (x[4]==5), axis=1)]

import operator
select_dict = {1:(operator.eq,3), 2:(operator.eq,2), 4:(operator.eq,5)}
%timeit _ = pandas_select(df, select_dict)

我得到的输出是:

In [6]: %timeit _ …

如何衡量/基准测试在python中执行的子进程的最大内存使用量？

所以我一直在寻找一种更快的方法来计算MD5校验和并在Fast MD5库中运行 - 但是当我在我的机器上使用Java 7进行基准测试时,它比Java版本慢.

要么我做一些愚蠢的事情(非常可能),要么Java 7已经实现了更好的算法(也可能).这是我超级简单的"基准" - 也许我今天没有足够的咖啡......

    MD5 digest = new MD5();
    System.out.println(MD5.initNativeLibrary(true));
    byte[] buff = IOUtils.readFully(new FileInputStream(new File("blahblah.bin")), 64000000, true);
    ByteBuffer buffer = ByteBuffer.wrap(buff);
    for (int j = 0; j < 100; j++) {
        start = System.currentTimeMillis();
        String md5Base64 = Utilities.getDigestBase64(buffer);
        end = System.currentTimeMillis();
        total = total + (end-start);
    }
    System.out.println("Took " + ((total)/100.00) + " ms. for " + buff.length+" bytes");
    total = 0;
    for (int i = 0; i < 100; i++) {
        start …

我的问题是关于性能与设计.我在PHP中对Getter和Setter有很多了解.而背后的想法是非常好的和有用的(Debugging,Sanitize).

所以我开始做基准测试:

class Foo {
    public $bar;

    public function __construct($bar) {
        $this->bar = $bar;
    }

    public function getBar() {
        return $this->bar;
    }

    public function setBar($bar) {
        $this->bar = $bar;
    }
}

$foo = new Foo(42);
Debug::ProcessingTimeSinceLastCall();

//Without Setter and Getter
for ($i = 0; $i < 1000000; $i++) {
    if ($foo->bar === 42) {
        $foo->bar = 43;
    } else {
        $foo->bar = 42;
    }
}
Debug::ProcessingTimeSinceLastCall('No Setter and Getter');

//With Getter and Setter
for ($i = 0; $i < 1000000; …

Nvidia GPU列表 - GeForce 900系列 - 有写道:

4单精度性能计算为着色器数量乘以基本核心时钟速度的2倍.

例如,对于GeForce GTX 970,我们可以计算性能:

1664核心*1050 MHz*2 = 3 494 GFlops峰值(3 494 400 MFlops)

我们可以在列中看到这个值 - 处理能力(峰值)GFLOPS - 单精度.

但为什么我们必须乘以2？

写道:http://devblogs.nvidia.com/parallelforall/maxwell-most-advanced-cuda-gpu-ever-made/

SMM使用基于象限的设计,具有四个32核处理模块,每个模块具有专用的warp调度程序,能够在每个时钟发送两条指令.

好的,nVidia Maxwell是超标量体系结构,每个时钟发送两条指令,但是1个CUDA内核(FP32-ALU)每个时钟可以处理多于1条指令吗？

我们知道1个CUDA-Core包含两个单元:FP32-unit和INT-unit.但INT-unit与GFlops(每秒浮点运算)无关.

即一个SMM包含:

• 128 FP32单元
• 128 INT单位
• 32 SFU-unit
• 32 LD/ST单元

要获得GFlops的性能,我们应该只使用:128个FP32单元和32个SFU单元.

即如果我们同时使用128个FP32单元和32个SFU单元,那么我们可以获得160个指令,每个SM每个时钟具有浮点运算.

也就是说,我们必须通过1,2 =(160/132)的instad为2.

1664核心*1050 MHz*1,2 = 2 096 GFlops峰值

为什么在wiki中写入我们必须多个核心*MHz乘2？

我写了以下基准:

#include <iostream> // cout
#include <math.h>   // pow
#include <chrono>   // high_resolution_clock    

using namespace std;
using namespace std::chrono;

int64_t calculate(int);

int main()
{
    high_resolution_clock::time_point t1, t2;

    // Test 1
    t1 = high_resolution_clock::now();
    calculate(200);
    t2 = high_resolution_clock::now();

    cout << "RUNTIME = " <<  duration_cast<nanoseconds>(t2 - t1).count() << " nano seconds" << endl;

    // Test 2   
    t1 = high_resolution_clock::now();
    calculate(200000);
    t2 = high_resolution_clock::now();

    cout << "RUNTIME = " <<  duration_cast<nanoseconds>(t2 - t1).count() << " nano seconds" << endl;
}

int64_t calculate(const …