标签: benchmarking

在客户端站点的管理部分中有一个操作,例如Admin :: Analytics(我没有构建但必须维护),它通过执行几十个相当密集的数据库查询来编译站点使用情况分析.在编译分析报告时,此功能始终是应用程序性能的瓶颈.但是,最近瓶颈已经变得非常糟糕,当访问时,网站会突然停止并无限期挂起.直到昨天我才有理由在服务器上运行"top"命令,但这样做我意识到Admin :: Analytics#index导致mysqld在四核,生产VPS上以高达350 +%的CPU功率旋转.

我已经下载了生产数据的新副本和生产日志.但是,当我在开发盒上本地访问Admin :: Analytics#index时,在使用生产数据时,它会在大约10-12秒内加载(并且利用我的双核CPU的~150 +%),这很遗憾.我想在mysql设置中可能会有一个突然发挥作用的差异.此外,数据库的mysqldump现在是531 MB,28天前只有336 MB.无论如何,我没有VPS上的root访问权限,所以调整mysqld性能会很麻烦,我真的很想知道这个问题的确切原因.但是,生产日志不包含信息.关于查询; 他们只是报告这些请求的长度,

我想我可以尝试提高生产中的日志级别来征求信息.关于由Admin :: Analytics#index执行的数据库查询,但同时我害怕在生产中复制这种行为,因为我不想再调用我们的主机来重新启动mysqld!此操作在其控制器中包含单个数据库请求,并在其视图中嵌入了几十个预准备语句!

您将如何进行基准测试/诊断和优化/修复此操作？!

(旁白:显然我想用Google Analytics或类似的解决方案完全取代此功能,但我需要在继续之前解决此问题.)

以下代码命名 fib.hs

import Criterion.Main (defaultMain)
fibZ = 1:1:zipWith (+) fibZ (tail fibZ)
main = defaultMain [
         bench "fibZ 10" $ \n -> fibZ (10+n-n)
       ]

错误

fib.hs:45:10: Not in scope: `bench'

怎么了？我从这里借了这个例子.

是否有内置的方法来对Laravel中的慢速代码进行基准测试和追踪？

或者只是做一个cachegrind更有效？

无论页面有多简单,我刚建立的其中一个网站上的每个页面都需要1-2秒才能加载.

这是我的剧本

require 'benchmark'
require 'ostruct'

Benchmark.bmbm do |x|
  n=10000
  array = n.times.map{ |i| OpenStruct.new id: i }
  hash = Hash[*(array.map{ |s| [s.id, s] }.flatten)]

  x.report('array') do
    array.find{ |s| s.id == 100}
  end
  x.report('hash') do
    hash[100]
  end
end

为什么n=100000我得到:

stack level too deep (SystemStackError)

？

不相关,但是,我是以最好的方式构建哈希？

在转换数据库的过程中,我尝试使用最佳/最快插入.AFAIK,惯用的大量插入应该准备语句处理程序,然后迭代数据插入它.像这样的东西:

my $sql = q|INSERT INTO test.table ( value ) VALUES ( ? ) |;  
my $sth = $dbh->prepare( $sql );  
for my $val ( 1 .. 1000000 ) {
  $sth->execute( $val );
}

我认为在state-declarator 的帮助下我可以将这个例程重构为函数,如下所示:

sub sql_state {  
  my ( $val ) = @_;
  state $sql = q|INSERT INTO test.table ( value ) VALUES ( ? ) |;  
  state $sth = $dbh->prepare( $sql );  
  $sth->execute( $val ) 
    or die "State";  
}  

所以现在$sql在所有插入过程中初始化一次,并且还$sth准备一次,这是增强的基础.

在迁移我的数据库期间,我觉得这种改进并没有像我希望的那样给我这样的胜利.然后我发现了一篇文章 …

我做了一个小测试:

In [12]: def test1():
    ...:     return 1,2,3
    ...: 

In [13]: def test2():
    ...:     return (1,2,3)
    ...: 

In [14]: %timeit a,b,c = test1()

最慢的运行时间比最快的运行时间长66.88倍.这可能意味着正在缓存中间结果.10000000次循环,最佳3:每循环92.7 ns

In [15]: %timeit a,b,c = test2()

最慢的运行时间比最快的时间长74.43倍.这可能意味着正在缓存中间结果.10000000次循环,最佳3:每循环80.1 ns

返回元组比返回多个值快约15%.为什么会这样？

我是一个新的Julia用户,我需要尽快找到大矩阵的特征向量*.我无法让Julia以与Matlab一样快的速度运行以下示例:

朱莉娅

const j = 1000 ::Int

A = Array{Float64}(j,j)

B = Array{Float64}(j,j)

f(x) = eigvecs(x)

A = randn(j,j)

B = f(A)

@time f(A)

输出时间:2.950973秒(12.31 k分配:76.445 MB,0.11%gc时间)

MATLAB

j = 1000;

A = randn(j,j);

tic

[v, d] = eig(A);

toc

经过的时间是1.161133秒.

我还检查了Matlab的1个线程,使用maxNumCompThreads = 1进行比较,但它仍然提供了与之前类似的时间(1.16s).我也尝试通过运行两次预编译加速Julia,并设置blas_set_num_threads(4)但这没有帮助.

我真的很感激有关如何改进我的Julia代码的任何建议!

*(我在OSX El Capitan 10.11.6上使用Matlab 2015b和Julia 0.4.7)

请帮助我解决有关Elixir与Ruby性能的基准问题.

我尝试在两种语言中实现相同的阶乘,而Ruby显示出比Elixir更好的结果:

# ruby_factorial_with_iterator.rb
def factorial_with_iterator(n)
  res = 1
  (1..n).each{|time| res *= time}
  res
end

p "factorial_with_iterator(200000)"
p factorial_with_iterator(200000)

运行后:

$ time ruby ruby_factorial_with_iterator.rb
real  0m18.378s
user  0m17.348s
sys   0m0.844s

和两个Elixir例子:

# elixir_factorial_with_iterator.exs
defmodule FactorialWithIterator do
  def of(n) do
    Enum.reduce(1..n, 1, &*/2)
  end
end

IO.puts "Factorial of 200000: "
IO.puts FactorialWithIterator.of(200000)

运行后:

$ time elixir elixir_factorial_with_iterator.exs
real  1m1.735s
user  1m1.556s
sys   0m0.104s

另一个例子:

# elixir_factorial_with_recursion.exs
defmodule FactorialWithRecursion do
  def of(0), do: 1
  def of(n) when n > 0 do
    n …

我正在解决Project Euler问题,我将每个问题都放在另一个文件中.当我尝试针对每个问题采用不同的方法时,我会在其各自的文件中为每个问题创建一系列基准.

我的目录结构如下:

euler/
    Cargo.lock
    Cargo.toml
    README.md
    src/
        main.rs
        p001.rs
        p002.rs
        ...etc.

内容main.rs是:

#![feature(test)]

extern crate primes;
extern crate test;

mod p001;
mod p002;
// ... etc

fn main() {}

当我运行时cargo bench,它会为我项目中的每个文件运行基准测试:

$ cargo bench
    Finished release [optimized] target(s) in 0.02 secs
     Running target/release/deps/euler_rust-5be87dff38a04da2

running 11 tests
test p001::bench_fold_sum                     ... bench:      12,955 ns/iter (+/- 13,501)
test p001::bench_for_sum                      ... bench:      11,385 ns/iter (+/- 7,383)
test p002::bench_for_sum                      ... bench:         270 ns/iter (+/- 90)
test p002::bench_takewhile_filter_mutable_sum ... …

我最近问了一个问题： 为什么迭代std :: array比迭代std :: vector快得多？

正如人们很快指出的那样，我的基准测试存在许多缺陷。因此，当我尝试确定基准时，我注意到这std::vector并不慢std::array，实际上，情况恰恰相反。

#include <vector>
#include <array>
#include <stdio.h>
#include <chrono>

using namespace std;

constexpr int n = 100'000'000;
vector<int> v(n);
//array<int, n> v;

int main()
{
    int res = 0;
    auto start = chrono::steady_clock::now();
    for(int x : v)
        res += x;
    auto end = chrono::steady_clock::now();
    auto diff = end - start;
    double elapsed =
        std::chrono::duration_cast<
            std::chrono::duration<double, std::milli>
        >(end - start).count();
    printf("result: %d\ntime: %f\n", res, elapsed);
}

我尝试从以前的基准进行改进的事情：

• 确保使用了结果，因此整个循环没有得到优化
• 使用-O3标志速度 …