标签: benchmarking

如何衡量用Java编写的代码的速度？

我计划开发软件,使用所有目前可用的AI和ML算法解决数独,并将时间与简单的蛮力方法进行比较.我需要测量每种算法的时间,我想问一下最好的方法是什么？非常重要的是,无论CPU电源/内存如何,程序都必须适用于任何机器.

谢谢.

我怎样才能测量加载页面所需的时间(使用各种不同的PHP语句)？

有点像这里的统计数据 - http://talks.php.net/show/drupal08/24

我用这个简单的算法进行矩阵乘法.为了更灵活,我使用了包含动态创建数组的matricies对象.

将此解决方案与我的第一个解决方案与静态数组进行比较,速度慢了4倍.我该怎么做才能加快数据访问速度？我不想改变算法.

 matrix mult_std(matrix a, matrix b) {
 matrix c(a.dim(), false, false);
 for (int i = 0; i < a.dim(); i++)
  for (int j = 0; j < a.dim(); j++) {
   int sum = 0;
   for (int k = 0; k < a.dim(); k++)
    sum += a(i,k) * b(k,j);
   c(i,j) = sum;
  }

 return c;
}

• 交换k和j循环迭代 - >性能改进
• 声明dim()并operator()() 作为inline- >性能改进
• 通过const引用传递参数 - > 性能损失!为什么？所以我不使用它.

现在的表现与现在的表现几乎相同.也许应该有一点改进. …

我决定要对特定函数进行基准测试,所以我天真地编写如下代码:

#include <ctime>
#include <iostream>

int SlowCalculation(int input) { ... }

int main() {
    std::cout << "Benchmark running..." << std::endl;
    std::clock_t start = std::clock();
    int answer = SlowCalculation(42);
    std::clock_t stop = std::clock();
    double delta = (stop - start) * 1.0 / CLOCKS_PER_SEC;
    std::cout << "Benchmark took " << delta << " seconds, and the answer was "
              << answer << '.' << std::endl;
    return 0;
}

一位同事指出,我应该声明start和stop变量volatile以避免代码重新排序.他建议优化器可以,例如,有效地重新排序代码,如下所示:

    std::clock_t start = std::clock();
    std::clock_t stop = …

问题描述:

我有这个自定义"校验和"功能:

NORMALIZER = 0x10000


def get_checksum(part1, part2, salt="trailing"):
    """Returns a checksum of two strings."""

    combined_string = part1 + part2 + " " + salt if part2 != "***" else part1
    ords = [ord(x) for x in combined_string]

    checksum = ords[0]  # initial value

    # TODO: document the logic behind the checksum calculations
    iterator = zip(ords[1:], ords)
    checksum += sum(x + 2 * y if counter % 2 else x * y
                    for counter, (x, y) in enumerate(iterator))
    checksum %= …

我不确定是使用:first还是:eq(0)选择器.我很确定他们总会返回相同的物体,但比另一个更快？

我相信这里的某人必须先对这些选择器进行基准测试,而且我不确定测试一个是否更快的最佳方法.

更新:这是我跑的替补席:

/* start bench */
for (var count = 0; count < 5; count++) {
    var i = 0, limit = 10000;
    var start, end;
    start = new Date();
    for (i = 0; i < limit; i++) {
        var $radeditor = $thisFrame.parents("div.RadEditor.Telerik:eq(0)");
    }
    end = new Date();
    alert("div.RadEditor.Telerik:eq(0) : " + (end-start));
    var start = new Date();
    for (i = 0; i < limit; i++) {
        var $radeditor = $thisFrame.parents("div.RadEditor.Telerik:first");
    }
    end = new …

我可以使用mysqlslap来测试特定的数据库/表吗？或者只是mysqlslap数据库？

谢谢

我在qemu和qemu-kvm中进行了以下基准测试,具有以下配置:

CPU: AMD 4400 process dual core with svm enabled, 2G RAM
Host OS: OpenSUSE 11.3 with latest Patch, running with kde4
Guest OS: FreeDos
Emulated Memory: 256M
Network: Nil
Language: Turbo C 2.0
Benchmark Program: Count from 0000000 to 9999999. Display the counter on the screen
     by direct accessing the screen memory (i.e. 0xb800:xxxx)

在qemu中运行时只需要6秒.

但是在qemu-kvm中运行需要89秒.

我一个接一个地运行基准测试,而不是并行测试.

我整晚都摸不着头脑,但仍然不知道为什么会这样.有人会给我一些提示吗？

我正在对一些python代码进行基准测试,我注意到了一些奇怪 我使用以下函数来测量迭代空for循环所需的速度:

def f(n):
    t1 = time.time()
    for i in range(n):
        pass
    print(time.time() - t1)

f(10**6)打印about 0.035,f(10**7)about 0.35,f(10**8)about 3.5和f(10**9)about 35.但是f(10**10)？好吧2000.这当然是意料之外的.为什么迭代10倍的元素需要花费60倍的时间？什么是python的for循环导致这个？这是特定于python的,还是会出现在很多语言中？

这个问题是关于访问数组和切片元素的速度,而不是关于将它们作为参数传递给函数的效率.

在大多数情况下,我希望数组比切片更快,因为切片是描述数组的连续部分的数据结构,因此在访问切片的元素时可能会涉及额外的步骤(间接地是其底层数组的元素) .

所以我写了一个小测试来测试一批简单的操作.有4个基准函数,前2个测试全局切片和全局数组,另外2个测试局部切片和本地数组:

var gs = make([]byte, 1000) // Global slice
var ga [1000]byte           // Global array

func BenchmarkSliceGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for j, v := range gs {
            gs[j]++; gs[j] = gs[j] + v + 10; gs[j] += v
        }
    }
}

func BenchmarkArrayGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for j, v …