A Traçar O Código Ruby

Question

A Traçar O Código Ruby

Para além da ruby-prof e da principal Classe Benchmark, o que usas para traçar o teu código Ruby? Em particular, como você encontra os pontos de estrangulamento em seu código? Quase sinto que preciso de trabalhar na minha pequena ferramenta só para descobrir onde o tempo todo está a ser gasto no meu código.

Eu sei que a ruby-prof fornece isto, mas a saída é francamente muito confusa e não torna fácil descobrir quais os blocos reais do seu próprio código são a fonte do problema (ele diz - lhe sobre qual o método chamadas levou mais tempo embora). Por isso, não estou a tirar tanto disto como gostaria, e não tenho conseguido usá-lo.

Talvez esteja a fazer mal? Há alternativas? As buscas no Google não trazem nada para mim.

34

ruby profiling profiler ruby-prof

Author: ehsanul, 2010-11-03

Source

4 answers

Para realmente perfurar o seu código tentestackprof .

Aqui está uma solução rápida sobre como usá-la.: Instale a jóia: gem install stackprof. No seu código adicione: require 'stackprof' e cerque a parte que deseja verificar com isto:

StackProf.run(mode: :cpu, out: 'stackprof-output.dump') do {YOUR_CODE} end

Depois de executar o seu programa em ruby, vá verificar o resultado no terminal com stackprof stackprof.dump:

Mode: cpu(1000)
Samples: 9145 (1.25% miss rate)
GC: 448 (4.90%)

 TOTAL    (pct)     SAMPLES    (pct)     FRAME
   236   (2.6%)         231   (2.5%)     String#blank?
   546   (6.0%)         216   (2.4%)     ActiveRecord::ConnectionAdapters::Mysql2Adapter#select
   212   (2.3%)         199   (2.2%)     Mysql2::Client#query_with_timing
   190   (2.1%)         155   (1.7%)     ERB::Util#html_escape``

Aqui você pode ver todos os seus métodos que requerem muito tempo. Agora a parte incrível: para perfurar basta fazer stackprof stackprof.dump --method String#blank? e você começa a saída para o método específico:

String#blank? (lib/active_support/core_ext/object/blank.rb:80)
  samples:   231 self (2.5%)  /    236 total (2.6%)
  callers:
    112  (   47.5%)  Object#present?
  code:
                                  |    80  |   def blank?
  187    (2.0%) /   187   (2.0%)  |    81  |     self !~ /[^[:space:]]/
                                  |    82  |   end

E você pode facilmente descobrir qual parte do seu código leva muito tempo para correr.

Se quiser obter uma saída visual faça stackprof stackprof.dump --graphviz >> stackprof.dot e use graphviz (brew install graphviz) dot -T pdf -o stackprof.pdf stackprof.dot obter uma bela saída PDF, que destaca os métodos que levam um longo tempo para correr.

12

Author: conscho, 2019-03-20 20:48:06

Esta é a minha própria pergunta,mas encontrei uma ferramenta tão incrível para traçar perfis que tenho que adicioná-la aqui.

Http://samsaffron.com/archive/2013/03/19/flame-graphs-in-ruby-miniprofiler

Flamegrafos fazem a fonte dos problemas de desempenho surpreendentemente óbvio , em relação a olhar para os backtraces.

3

Author: ehsanul, 2014-01-25 04:26:56

Existe também {[0] } ou de forma equivalente dentro da fonte de Ruby, require 'profile'

Documentação:

Https://ruby-doc.org/stdlib-2.1.0/libdoc/profiler/rdoc/Profiler__.html

3

Author: Throw Away Account, 2017-07-12 18:57:33

score 8 · Accepted Answer

Muitos profilers são assim. O que você precisa saber não é Onde o programa gasta seu tempo, mas Por que. alguma referência à análise dinâmica do Código?

Adicionei: eis como encontro "estrangulamentos" no meu código. (Odeio essa palavra.) Eis uma lista de razões.

É perfeitamente natural assumir que para encontrar "estrangulamentos" é preciso fazer muitas medições. É tão natural que quase todos os profilers são baseados em ele. Na verdade, encontrar e medir não são o mesmo problema. A medição é necessária para ver se o que você encontrou (e fixo) fez a diferença. Encontrar o que consertar, para mim, é mais como Debug do que medir. A maneira mais simples de explicar é começar a partir de um ciclo infinito, ou quase infinito. Como é que o encontraste? Pára e olha para a pilha, certo? Porque sabes que o problema está algures na pilha. Você só precisa pausá-lo uma vez, e então você precisa estudar o código na pilha. Pausa-o algumas vezes se quiseres ter a certeza que o encontraste. Suponha que o código só demora o dobro do tempo necessário. Isso significa que quando você pausa, há 50% de chance que você vai vê-lo fazendo a coisa desnecessária. Se você parar e olhar para ele 10 vezes, você vai pegá-lo no ato cerca de 5 vezes. Na verdade, assim que você vê-lo fazendo algo que você pode otimizar em apenas 2 amostras, você encontrou um "gargalo". Arranja - o, mede a velocidade, mostra-o, e repetir. Mesmo que o seu maior problema não seja muito grande, este método acabará por encontrá-lo. Além disso, há um fenômeno de ampliação, onde pequenos problemas se tornam mais fáceis de encontrar depois que você removeu os maiores. Isso permite que você continue até que o código seja quase ideal. P. S. Depois de fazeres isto, ainda pode haver oportunidades para acelerar. Por exemplo, algoritmos de otimização podem depender da estabilidade numérica. Arquiteturas movidas por mensagens podem tornar mais difícil localize porque é que o código está a ser executado. Em software em tempo real, um problema de desempenho só pode acontecer ocasionalmente, e ser menos fácil de provar. Isto requer mais inteligência. Cair para trás só de medir não é suficiente.