O que Class::MethodMaker faz exatamente?

Question

Quero saber qual é exatamente a sequência de chamadas que ocorre quando um getter/setter criado através de Class::MethodMaker é chamado?

Quanto mais caros são os getter/setters definidos pelo MethodMaker do que os nativos (sobrescritos no módulo)?

Answer 1

Não tenho uma resposta simples para sua pergunta sobre o desempenho do Class::MethodMaker.Como mencionado na resposta anterior, você pode usar o depurador para descobrir o que está acontecendo nos bastidores.Porém, eu sei que Class::MethodMaker gera enorme quantidades de código no momento da instalação.Isso indicaria três coisas distintas para mim:

1. Em relação ao tempo de execução, é provavelmente no lado mais rápido de toda a série de geradores de métodos.Por que gerar muito código no momento da instalação?
2. Ele instala O(Megabytes) de código em seu disco!
3. Pode ser potencialmente lento em tempo de compilação, dependendo de quais partes do código gerado são carregadas para casos de uso simples.

Você realmente precisa gastar alguns minutos para pensar sobre o que realmente precisa.Se você deseja métodos de acesso simples gerados automaticamente, mas escreve algo mais complicado à mão, talvez dê uma olhada em Class::Accessor::Fast.Ou, se você quiser os métodos de acesso mais rápidos possíveis, investigue Class::XSAccessor, cujos métodos extra-simples são executados como código C/XS e são aproximadamente duas vezes mais rápidos que o acessador Perl mais rápido.(Observação:Eu escrevi o último módulo, então considere isso com cautela.)

Mais um comentário:se você for usar o kit de ferramentas PAR/PAR::Packer para empacotar seu aplicativo, observe que a grande quantidade de código de Class::MethodMaker resulta em um executável significativamente maior e em um tempo de inicialização inicial mais lento.Além disso, há uma incompatibilidade conhecida entre C::MethodMaker e PAR.Mas isso pode ser considerado um bug PAR.

Answer 2

É exatamente para isso que servem as ferramentas de depuração :)

Dê uma olhada no perldebug documentos, especialmente a seção sobre criação de perfil.

Em particular, executar seu script com perl -dDProf filename.pl irá gerar um arquivo tt.out do qual a ferramenta dprofpp (distribuída com Perl) pode produzir um relatório.

Usei o seguinte script de teste simples:

#!/usr/bin/perl

package Foo;
use strict;
use Class::MethodMaker [ scalar => ['bar'], new => ['new'] ];

package main;
use strict;

my $foo = new Foo;
$foo->bar('baz');
print $foo->bar . "\n";

Executá-lo com perl -d:DProf methodmakertest.pl e depois usar dprofpp na saída deu:

[davidp@supernova:~/tmp]$ dprofpp tmon.out
Class::MethodMaker::scalar::scal0000 has 1 unstacked calls in outer
Class::MethodMaker::Engine::new has 1 unstacked calls in outer
AutoLoader::AUTOLOAD has -2 unstacked calls in outer
Total Elapsed Time =  0.08894 Seconds
  User+System Time =  0.07894 Seconds
Exclusive Times
%Time ExclSec CumulS #Calls sec/call Csec/c  Name
 25.3   0.020  0.020      4   0.0050 0.0050  Class::MethodMaker::Constants::BEG
                                             IN
 25.3   0.020  0.029     12   0.0017 0.0025  Class::MethodMaker::Engine::BEGIN
 12.6   0.010  0.010      1   0.0100 0.0100  DynaLoader::dl_load_file
 12.6   0.010  0.010      2   0.0050 0.0050  AutoLoader::AUTOLOAD
 12.6   0.010  0.010     14   0.0007 0.0007  Class::MethodMaker::V1Compat::reph
                                             rase_prefix_option
 0.00   0.000  0.000      1   0.0000 0.0000  Class::MethodMaker::scalar::scal00
                                             00
 0.00   0.000  0.000      1   0.0000 0.0000  Class::MethodMaker::Engine::new
 0.00       - -0.000      1        -      -  DynaLoader::dl_undef_symbols
 0.00       - -0.000      1        -      -  Class::MethodMaker::bootstrap
 0.00       - -0.000      1        -      -  warnings::BEGIN
 0.00       - -0.000      1        -      -  warnings::unimport
 0.00       - -0.000      1        -      -  DynaLoader::dl_find_symbol
 0.00       - -0.000      1        -      -  DynaLoader::dl_install_xsub
 0.00       - -0.000      1        -      -  UNIVERSAL::VERSION
 0.00       - -0.000      1        -      -  Foo::new

As duas chamadas mais caras são os blocos Class::MethodMaker::Constants::BEGIN e Class::MethodMaker::Engine::BEGIN, que são obviamente chamados apenas em tempo de compilação, portanto, podem retardar um pouco a compilação do seu script, mas o uso subsequente da criação/acesso do objeto não é afetado por ele.

Answer 3

A verdadeira questão é:isso importa?

É mais um módulo gerador de acessadores.Todos esses módulos têm uma relação entre velocidade e funcionalidade.Basta escolher um que ofereça tudo que você precisa.Não é provável que os acessadores se tornem um gargalo em seu aplicativo.

Answer 4

@Leon Timmermans

Estou ciente do fato de que há alguma compensação entre velocidade/funcionalidade, mas quero ter uma ideia de quão bom/ruim é isso?E muito melhor, se eu puder especificar as implementações para que seja mais fácil decidir.

Answer 5

Seguindo minha resposta anterior, se você quiser ver exatamente o que está acontecendo em detalhes, execute seu script no depurador com o modo de rastreamento ativado (perl -d filename.pl, diga "t" para rastrear e depois "r " para executar o script;espere muitos resultados!).