Newsgroup: it.comp.lang.perl
Titolo: Prestazioni: "use" vs "require"

Ciao a tutti,
Sto preparando una serie di moduli in parte collegati.
Alcuni sono piuttosto grossi e richiamano altri standard tipo DBI, CGI, ecc.
Ho approntato uno script di prova per verificarli. Lo script ha varie
funzioni che vengono invocate a seconda delle richieste fatte. In breve...
per ogni sessione solo alcuni moduli vengono usati, mai tutti insieme. Per
cui avevo pensato di alleggerire il sistema usando invece di:
use MODULO1;
use MODULO2;
...
posto all'inizio, usare:
eval {
        require MODULO1;
        MODULO1->import();
};
if ($@) {
        die "Errore:\nil modulo MODULO1 non e' istallato o non e' in un path
inserito in \@INC.";
}
inserito nelle funzioni per caricare solamente i moduli necessari. 
La cosa che mi ha colpito è che utilizzando il modulo Benchmark.pm ho visto
che "use", pur caricando tutti i moduli anche non usati effettivamente, è
molto più efficiente di "require - import", che carica solo quelli
effettivamente usati.
ad esempio 0.02 di CPU contro 0.04
Vi risulta che effettivamente sia così o sbaglio qualcosa?
Grazie.
-- 
-- Marco Allegretti --
http://www.shishii.com

 Vi risulta che effettivamente sia cosě o sbaglio qualcosa?
Difficile stabilirlo. Puoi mandare lo script che usi per il fare
il benchmark?
ciao,
S.
-- 
Stefano Rodighiero      |  
http://larsen.perlmonk.org
mailto:
lar...@perl.it
   |  
http://www.perl.it

 il benchmark?
Parte dello script di prova:
~~~~~~~~~~~~~~~~~~~~
#!/usr/bin/perl -w
use strict;
use warnings;
use utf8;
use CGI::Carp qw(fatalsToBrowser);
use CGI;
use Benchmark;
my $t0 = new Benchmark;
use lib "/var/www/cgi-bin/MyDB_oop";
use MyPM::MyConfig qw(:ADMIN :DB :PATH);
use MyPM::Login;
use MyPM::PannelloLogin;
use MyPM::PannelloInsMod;
use MyPM::PannelloCerca;
use MyPM::PannelloTable;
use MyPM::DBActions;
use MyPM::GetErrors;
use MyPM::GetConfirm;
use MyPM::BarraNav;
[...]
# funzione che a cui si riferisce la prova
# e che non fa altro che stampare un form per il login
# In realtà questa funzione usa solo i moduli:
# MyPM::MyConfig, MyPM::PannelloLogin.
sub PanLogin {
        my ($verify) = @_;
        my $pan = PannelloLogin->new({
                'css'                   => $MyConfig::css_url,
                'titolo'                => 'Pannello Gestione Database',
                'bgcolor'       => '#eeeeee',
                'script'                => $MyConfig::admin_url,
                'verify'                => $verify,
                'cookie'                => 0
        });
        $pan->stampa();
}
# in queste condizioni mi da un uso di CPU di 0.02
~~~~~~~~~~~~~~~~~~~~
se invece lo scrivo così mi da un uso di 0.04:
~~~~~~~~~~~~~~~~~~~~
#!/usr/bin/perl -w
use strict;
use warnings;
use utf8;
use CGI::Carp qw(fatalsToBrowser);
use CGI;
use Benchmark;
my $t0 = new Benchmark;
use lib "/var/www/cgi-bin/MyDB_oop";
use MyPM::MyConfig qw(:ADMIN :DB :PATH);
[...]
# funzione che a cui si riferisce la prova
# e che non fa altro che stampare un form per il login
# In realtà questa funzione usa solo i moduli:
# MyPM::MyConfig, MyPM::PannelloLogin.
sub PanLogin {
        eval {
           require MyPM::PannelloLogin;
           MyPM::PannelloLogin->import();
        };
        if ($@) {
           die "Errore: modulo MyPM::PannelloLogin non raggiungibile\n";
        }
        my ($verify) = @_;
        my $pan = PannelloLogin->new({
                'css'                   => $MyConfig::css_url,
                'titolo'                => 'Pannello Gestione Database',
                'bgcolor'       => '#eeeeee',
                'script'                => $MyConfig::admin_url,
                'verify'                => $verify,
                'cookie'                => 0
        });
        $pan->stampa();
}
~~~~~~~~~~~~~~~~~~~~
Come si vede in questo secondo caso viene caricato solo il modulo
MyPM::PannelloLogin e non tutta la lunga lista vista nel primo caso. Non
ostante ciò il tempo di CPU raddoppia.
C'è una così forte differenza di efficienza tra "use" e "require - import"?


 
Nota che questa istruzione viene eseguita *dopo* che l'inclusione dei 
moduli. La direttiva 'use' equivale, infatti, a una combinazione di 
'require' e 'import' eseguiti in un blocco BEGIN.
Mi pare perciò che il tuo benchmark misuri soltanto il tempo di esecuzione 
della funzione, il quale ovviamente nel secondo caso è maggiore.
Max

Max M. ha scritto:

giusto!!!! Penso che hai proprio ragione... ora provo a fare dei test
tramite il comando "time" di linux.


shishii ha scritto:

calcolando le prestazioni da sistema, tramite:
$ time ./
mioscript.pl
"require - import" è in vantaggio rispetto ad "use" di un bel pò, circa un
20% di tempo in media in meno. E questo penso che sia dovuto al fatto che
lo script carica solo i moduli effettivamente necessari per quella
sessione.
Grazie.
