Gli script di automazione di DBT3

DBT-3 (OSDL Database Test 3) è uno strumento di workload per il kernel Linux sviluppato da OSDL (Open Source Development Labs, inc), e basato su TPC-H del Transaction Performance Processing Council (TPC).

DBT-3, come TPC-H, simula un effettivo sistema di supporto al decision making e modella complesse applicazioni di business analysis che svolgono un lavoro di analisi dei dati per poter prendere le decisioni migliori. Eseguendo il workload simulato da DBT-3, è possibile verificare e misurare le prestazioni del kernel Linux in un effettivo sistema di supporto al decision making.

DBT-3 utilizza lo "scale factor (SF)" come indicatore dello stress sul sistema. Modificando l'SF, è possibile cambiare le dimensioni del database perché raggiunga SF volte le sue vecchie dimensioni.

I test eseguiti da DBT-3 comprendono i tre elencati sotto. Misura i loro tempi di esecuzione, così come le informazioni sullo stato del sistema e le statistiche sul database.

  1. Load test
    • Inserisce nel database i dati che verranno poi usati dai test Power e Throughput. Esegue una bulk insert dei grandi dati CSV corrispondenti allo Scale Factor.
  1. Power test
    • Esegue 22 query complesse.
  1. Throughput test
    • Esegue le stesse 22 query del test Power, ma simultaneamente in più di un processo.

Ai fini di questo task, viene eseguito solo il test Power su un database precedentemente preparato con diversi SF. Il tempo di esecuzione di ogni query viene misurato e registrato in un database. Successivamente i risultati di un unico test con tutte le 22 query verranno disegnati in un istogramma per comparare le differenti configurazioni.

Preparazione dell'ambiente dei benchmark

Permessi per sudo

L'utente che eseguirà i benchmark deve avere i permessi per sudo sulla macchina.

Per pulire le cache di sistema tra un'esecuzione di una query e l'altra, lo script di automazione lancia il seguente comando:

sudo /sbin/sysctl vm.drop_caches=3

Il comando deve essere eseguito con i permessi da superutente. Anche se l'utente passa una password a sudo, questa password scade dopo un timeout. Perché il comando funzioni senza password, occorre aggiungere al file visudo la riga seguente (per modificarlo si può usare il comando "sudo visudo"):

'username' ALL=NOPASSWD:/sbin/sysctl

...dove 'username' è l'utente che esegue il benchmark.

Il software necessario

I benchmark automatizzati di DBT3 necessitano dei seguenti software:

  • Config::Auto un modulo Perlche legge i file di configurazione. Il comando per installarlo è:
    sudo cpan Config::Auto
    
  • DBD::mysql un modulo Perl per connettersi a MariaDB/MySQL e PostgreSQL. Il comando per installarlo è:
    sudo cpan DBD::mysql
    

NOTA: E' possibile che appaia un errore che dice che CPAN non è riuscito a trovare mysql_config. In questo caso occorre installare la libreria client di sviluppo mysql. In OpenSuse il comando è:

sudo zypper install libmysqlclient-devel

In alternativa questo modulo può essere installato manualmente seguento queste istruzioni:

  1. Si scarichi DBD-mysql-4.020.tar.gz da http://search.cpan.org/~capttofu/DBD-mysql-4.020/lib/DBD/mysql.pm e lo si decomprima
  1. Si esegua lo script Perl PerlMake.pl sotto la directory decompressa:
    perl Makefile.PL --mysql_config=/path/to/some/mysql_binary_distribution/bin/mysql_config
    
  1. Si esegua make per compilare DBD::mysql:
    make
    
  1. Si aggiungano i percorsi necessari per poter eseguire DBD::mysql:
    export PERL5LIB="/path/to/unzipped_DBD_mysql/DBD-mysql-4.020/lib"
    export LD_LIBRARY_PATH="/path/to/unzipped_DBD_mysql/DBD-mysql-4.020/blib/arch/auto/DBD/mysql/:/path/to/some/mysql_binary_distribution/lib/"
    

DBMS testati

NOTA: DBT3 richiede molto spazio su disco (per esempio i database MySQL 5.5.x + MyISAM con scale factor 30 necessita di circa 50 GB). Inoltre alcune query richiedono l'uso delle tabelle temporanee sotto la directory specificata nel parametro --tmpdir di mysqld. Nei file della configurazione già pronta la directory temporanea punta alla directory di sistema di mysql della distribuzione binaria, ma è meglio accertarsi che la suddetta directory abbia abbastanza spazio libero.

Istruzioni di installazione

NOTA: La directory in cui tutti i file verranno scaricati e installati verrà chiamata $PROJECT_HOME. Ed esempio potrebbe essere ~/benchmark/dbt3.

Scaricare mariadb-tools

  1. Ci si porti nella cartella del progetto
    cd $PROJECT_HOME
    
  2. Si scarichi la branch più recente da LaunchPad con Bazaar:
    bzr branch lp:mariadb-tools
    

Il progetto di dbt3 dovrebbe trovarsi nella seguente directory:

$PROJECT_HOME/mariadb-tools/dbt3_benchmark/

Il progetto dbt3_benchmark contiene i seguenti file e directory:

  • config una cartella contenente i file di configurazione di MariaDB, MySQL e PostgreSQL. E' suddivisa in sottodirectory chiamate 'sXX', dove XX è lo scale factor.
  • dbt3_mysql una cartella contenente i file necessari per preparare i database di DBT3 e le query di test da eseguire con MySQL e MariaDB
  • tests una cartella contenente le varie configurazioni dei test. Dentro ci sono le seguenti subdirectory:
    • db_conf qui si trovano i file di configurazione dei database.
    • queries_conf qui ci sono i file di configurazione delle varie query.
    • results_db_conf qui si trova la configurazione del database dei risultati
    • test_conf qui ci sono le configurazioni dei test
    • launcher.pl uno script in Perl che automatizza il test. I dettagli su come invocarlo e sulle sue funzionalità si trovano più avanti in questa pagina.

Preparare il workload e le query

Ai fini del benchmark da DBT3-1.9, si necessita soltanto di DBGEN e QGEN. DBGEN è lo strumento che genera il workload per i test e QGEN è lo strumento che genera le query da usare nel test.

  1. Recarsi su http://sourceforge.net/projects/osdldbt/files/dbt3/
  1. Scaricare l'archivio di DBT3 1.9 nella cartella del progetto $PROJECT_HOME
  1. Decomprimere l'archivio nella cartella del progetto
    cd $PROJECT_HOME
    tar -zxf dbt3-1.9.tar.gz
    
  1. Copiare il file tpcd.h nella cartella dbt3. Questo passaggio comprende le etichette che sono necessarie a MySQL/MariaDB nel costruire le query.
    cp $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/tpcd.h $PROJECT_HOME/dbt3-1.9/src/dbgen/
    
  1. Copiare il file Makefile sotto $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/ nella cartella dbt3
  • NOTA: Questo passaggio deve essere eseguito solo se si desidera sovrascrivere il comportamento predefinito di QGEN. Dopo aver copiato questo Makefile e compilato il progetto, QGEN verrà impostato per generare le query per MariaDB/MySQL. Se si salta questo passaggio, per default QGEN genererà le query per PostgreSQL.
    cp $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/Makefile $PROJECT_HOME/dbt3-1.9/src/dbgen/
    
  1. Recarsi in $PROJECT_HOME/dbt3-1.9/src/dbgen e si compili il progetto
    cd $PROJECT_HOME/dbt3-1.9/src/dbgen
    make
    
  1. Impostare la variabile DSS_QUERY con la cartella contenente le query modello per MariaDB/MySQL o per PostgreSQL
    1. Se si desidera creare le query più adatte al dialetto di MariaDB/MySQL, si esegua il seguente comando:
      export DSS_QUERY=$PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/mysql_queries/
      
    2. Se si desidera usare i modelli predefiniti di PostgreSQL, si esegua il seguente comando:
      export DSS_QUERY=$PROJECT_HOME/dbt3-1.9/queries/pgsql/
      
  1. Creare una directory che conterrà le query così generate, in
    mkdir $PROJECT_HOME/gen_query
    
  1. Generare le query

NOTA: Gli esempi usano uno scale factor di 30. Se si desidera un SF diverso, si imposti il parametro -s

  • cd $PROJECT_HOME/dbt3-1.9/src/dbgen
    ./qgen -s 30 1 > $PROJECT_HOME/gen_query/s30-m/1.sql
    ./qgen -s 30 2 > $PROJECT_HOME/gen_query/s30-m/2.sql
    ./qgen -s 30 3 > $PROJECT_HOME/gen_query/s30-m/3.sql
    ./qgen -s 30 4 > $PROJECT_HOME/gen_query/s30-m/4.sql
    ./qgen -s 30 5 > $PROJECT_HOME/gen_query/s30-m/5.sql
    ./qgen -s 30 6 > $PROJECT_HOME/gen_query/s30-m/6.sql
    ./qgen -s 30 7 > $PROJECT_HOME/gen_query/s30-m/7.sql
    ./qgen -s 30 8 > $PROJECT_HOME/gen_query/s30-m/8.sql
    ./qgen -s 30 9 > $PROJECT_HOME/gen_query/s30-m/9.sql
    ./qgen -s 30 10 > $PROJECT_HOME/gen_query/s30-m/10.sql
    ./qgen -s 30 11 > $PROJECT_HOME/gen_query/s30-m/11.sql
    ./qgen -s 30 12 > $PROJECT_HOME/gen_query/s30-m/12.sql
    ./qgen -s 30 13 > $PROJECT_HOME/gen_query/s30-m/13.sql
    ./qgen -s 30 14 > $PROJECT_HOME/gen_query/s30-m/14.sql
    ./qgen -s 30 15 > $PROJECT_HOME/gen_query/s30-m/15.sql
    ./qgen -s 30 16 > $PROJECT_HOME/gen_query/s30-m/16.sql
    ./qgen -s 30 17 > $PROJECT_HOME/gen_query/s30-m/17.sql
    ./qgen -s 30 18 > $PROJECT_HOME/gen_query/s30-m/18.sql
    ./qgen -s 30 19 > $PROJECT_HOME/gen_query/s30-m/19.sql
    ./qgen -s 30 20 > $PROJECT_HOME/gen_query/s30-m/20.sql
    ./qgen -s 30 21 > $PROJECT_HOME/gen_query/s30-m/21.sql
    ./qgen -s 30 22 > $PROJECT_HOME/gen_query/s30-m/22.sql
    
  1. Generare le query explain:
    ./qgen -s 30 -x 1 > $PROJECT_HOME/gen_query/s30-m/1_explain.sql
    ./qgen -s 30 -x 2 > $PROJECT_HOME/gen_query/s30-m/2_explain.sql
    ./qgen -s 30 -x 3 > $PROJECT_HOME/gen_query/s30-m/3_explain.sql
    ./qgen -s 30 -x 4 > $PROJECT_HOME/gen_query/s30-m/4_explain.sql
    ./qgen -s 30 -x 5 > $PROJECT_HOME/gen_query/s30-m/5_explain.sql
    ./qgen -s 30 -x 6 > $PROJECT_HOME/gen_query/s30-m/6_explain.sql
    ./qgen -s 30 -x 7 > $PROJECT_HOME/gen_query/s30-m/7_explain.sql
    ./qgen -s 30 -x 8 > $PROJECT_HOME/gen_query/s30-m/8_explain.sql
    ./qgen -s 30 -x 9 > $PROJECT_HOME/gen_query/s30-m/9_explain.sql
    ./qgen -s 30 -x 10 > $PROJECT_HOME/gen_query/s30-m/10_explain.sql
    ./qgen -s 30 -x 11 > $PROJECT_HOME/gen_query/s30-m/11_explain.sql
    ./qgen -s 30 -x 12 > $PROJECT_HOME/gen_query/s30-m/12_explain.sql
    ./qgen -s 30 -x 13 > $PROJECT_HOME/gen_query/s30-m/13_explain.sql
    ./qgen -s 30 -x 14 > $PROJECT_HOME/gen_query/s30-m/14_explain.sql
    ./qgen -s 30 -x 15 > $PROJECT_HOME/gen_query/s30-m/15_explain.sql
    ./qgen -s 30 -x 16 > $PROJECT_HOME/gen_query/s30-m/16_explain.sql
    ./qgen -s 30 -x 17 > $PROJECT_HOME/gen_query/s30-m/17_explain.sql
    ./qgen -s 30 -x 18 > $PROJECT_HOME/gen_query/s30-m/18_explain.sql
    ./qgen -s 30 -x 19 > $PROJECT_HOME/gen_query/s30-m/19_explain.sql
    ./qgen -s 30 -x 20 > $PROJECT_HOME/gen_query/s30-m/20_explain.sql
    ./qgen -s 30 -x 21 > $PROJECT_HOME/gen_query/s30-m/21_explain.sql
    ./qgen -s 30 -x 22 > $PROJECT_HOME/gen_query/s30-m/22_explain.sql
    

Ora, le query generate per i test su MariaDB/MySQL sono pronte e si trovano nella directory $PROJECT_HOME/gen_query/s30-m/ (-m sta per MariaDB/MySQL).

Un'organizzazione ulteriore delle directory è lasciata all'utente.

  1. Creare una directory per il workload da generare
    mkdir $PROJECT_HOME/gen_data/s30
    
  1. Impostare la variabile DSS_PATH con la cartella che conterrà i dati delle tabelle. Il workload dei test si troverà lì.
    export DSS_PATH=$PROJECT_HOME/gen_data/s30/
    
  1. Generare i dati delle tabelle
  • NOTA: L'esempio usa uno scale factor = 30. Per modificarlo, ci si serva del parametro -s.
    ./dbgen -vfF -s 30
    
  • Ora i dati generati si trovano nella cartella impostata in $DSS_PATH = $PROJECT_HOME/gen_data/

Ai fini di questo benchmark, questi passaggi sono stati eseguiti con uno scale factor di 30 e si trovano su facebook-maria1 ai seguenti percorsi:

  • /benchmark/dbt3/gen_data/s30 i dati con uno scale factor di 30
  • /benchmark/dbt3/gen_query/s30-m query generate per MariaDB/MySQL con scale factor 30
  • /benchmark/dbt3/gen_query/s30-p query generate per PostgreSQL con scale factor 30

Si veda Esempio di tempi di preparazione di DBT3 per sapere quanto tempo è necessario per preparare i database per i test.

Scaricare MySQL 5.5.x

  1. Si scarichi il file tar.gz nella cartella del progetto $PROJECT_HOME/bin/
  1. Si scompatti l'archivio con il comando seguente:
    gunzip < mysql-5.5.x-linux2.6-x86_64.tar.gz |tar xf -
    

Ora il server si dovrebbe avviare con questo comando:

$PROJECT_HOME/bin/mysql-5.5.x-linux2.6-x86_64/bin/mysqld_safe --datadir=some/data/dir &

Scaricare MySQL 5.6.x

  1. Si scarichi il file tar.gz nella cartella del progetto $PROJECT_HOME/bin/
  1. Si scompatti l'archivio con il comando seguente:
    gunzip < mysql-5.6.x-m5-linux2.6-x86_64.tar.gz |tar xf -
    

Ora il server si dovrebbe avviare con questo comando:

$PROJECT_HOME/bin/mysql-5.6.x-m5-linux2.6-x86_64/bin/mysqld_safe --datadir=some/data/dir &

Scaricare e compilare MariaDB 5.3.x / MariaDB 5.5.x

NOTA: Questi passaggi si applicano anche a MariaDB 5.5.x, cambiando soltanto il numero della versione

  1. Si scarichi con Bazaar il progetto mariadb 5.3
    bzr branch lp:maria/5.3
    mv 5.3/ mariadb-5.3
    
  1. Si compili MariaDB
    cd mariadb-5.3/
    ./BUILD/compile-amd64-max
    
  1. Si crei un file tar.gz
    ./scripts/make_binary_distribution
    
  1. Si sposti il file tar.gz così generato e lo si scompatti in $PROJECT_HOME/bin, dove verrà usato dallo script di automazione
    mv mariadb-5.3.x-beta-linux-x86_64.tar.gz $PROJECT_HOME/bin/
    cd $PROJECT_HOME/bin/
    tar -xf mariadb-5.3.x-beta-linux-x86_64.tar.gz
    

Ora il server si dovrebbe avviare con il seguente comando:

$PROJECT_HOME/bin/mariadb-5.3.x-beta-linux-x86_64/bin/mysqld_safe --datadir=some/data/dir &

Preparare i database per i benchmark

NOTA: Queste istruzioni sono identiche per MariaDB, MySQL 5.5.x e MySQL 5.6.x, modificando solo le directory dei database, qui chiamate $DB_HOME (per esempio, per MySQL 5.5.x, $DB_HOME è $PROJECT_HOME/bin/mysql-5.5.x-linux2.6-x86_64). Inoltre si possono preparare i database di test dello Storage Engine InnoDB. Le istruzioni per preparare PostgreSQL si trovano nella sezione per scaricare, compilare e preparare PostgreSQL, più avanti in questa pagina.

  1. Si apra il file $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/make-dbt3-db_innodb.sql e si modifichino i valori nelle chiamate ai comandi SQL che assomigliano al seguente:
    LOAD DATA INFILE '/some/path/to/gen_data/nation.tbl' into table nation fields terminated by '|';
    
  • Sembrano tutti uguali, ma operano su tabelle diverse.
  • Si sostituisca "/some/path/to/gen_data/" con la directory corretta, in cui si trovano i dati generati. Il nuovo comando dovrebbe assomigliare al seguente:
    LOAD DATA INFILE '~/benchmark/dbt3/gen_data/s30/nation.tbl' into table nation fields terminated by '|';
    
  1. Si crei un database MySQL vuoto in una cartella che verrà usata per il benchmark
    cd $DB_HOME
    ./scripts/mysql_install_db --defaults-file=$PROJECT_HOME/mariadb-tools/dbt3_benchmark/config/s30/load_mysql_myisam_my.cnf --basedir=$DB_HOME --datadir=$PROJECT_HOME/db_data/myisam-s30/
    
  • NOTA: Per InnoDB si modifichino i defaults-file in load_mysql_innodb_my.cnf.
  1. Si avvii il processo mysqld ./bin/mysqld_safe --defaults-file=$PROJECT_HOME/mariadb-tools/dbt3_benchmark/config/s30/load_mysql_myisam_my.cnf --tmpdir=$PROJECT_HOME/temp/ --socket=$PROJECT_HOME/temp/mysql.sock --datadir=$PROJECT_HOME/db_data/myisam-s30/ &
  • NOTA: Per InnoDB si modifichino i defaults-file in load_mysql_innodb_my.cnf. Inoltre ci si accerti di avere abbastanza spazio nella directory impostata nel parametro --tmpdir, perché il caricamento del database richiede molto spazio temporaneo.
  1. Si carichino i dati nel database eseguendo il file make-dbt3-db_pre_create_PK.sql (per InnoDB) o make-dbt3-db_post_create_PK.sql (per MyISAM)./bin/mysql -u root -S $PROJECT_HOME/temp/mysql.sock < $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/make-dbt3-db_post_create_PK.sql
  • NOTA: Per velocizzare la creazione, si raccomanda di usare make-dbt3-db_pre_create_PK.sql per caricare i database InnoDB e make-dbt3-db_post_create_PK.sql per i database MyISAM.
  1. Arrestare il server dei database:
    ./bin/mysqladmin --user=root --socket=$PROJECT_HOME/temp/mysql.sock shutdown 0
    

Ora si ha un database caricato con SF 30. La datadir è $PROJECT_HOME/db_data/myisam-s30/

Gli stessi passaggi possono essere ripetuti con SF differenti e per differenti Storage Engine.

Scaricare, compilare e preparare PostgreSQL

  1. Ci si rechi su http://www.postgresql.org/ftp/source/v9.1rc1/
  1. Si scarichi il file tramite il link postgresql-9.1rc1.tar.gz
  1. Si scompatti l'archivio nella cartella del progetto
    gunzip < postgresql-9.1rc1.tar.gz |tar xf -
    
  1. Per installare PostgreSQL si eseguano i seguenti comandi nella shell:
    mkdir $PROJECT_HOME/PostgreSQL_bin
    cd $PROJECT_HOME/postgresql-9.1rc1 
    ./configure --prefix=$PROJECT_HOME/bin/PostgreSQL_bin 
    make
    make install
    
  • NOTA: Lo script di configurazione potrebbe non essere in grado di trovare le seguenti librerie: readline e zlib. In questo caso si esegua la configurazione senza di esse, aggiungendo i seguenti parametri alla riga di comando: --without-readline --without-zlib
  1. Si prepari il database dei test:
    mkdir $PROJECT_HOME/db_data/postgre_s30
    cd $PROJECT_HOME/bin/PostgreSQL_bin
    ./bin/initdb -D $PROJECT_HOME/db_data/postgre_s30
    
  1. Si avvii il server:
    ./bin/postgres -D $PROJECT_HOME/db_data/postgre_s30 -p 54322 &
    
  1. Si carichi il dataload nel DB
    ./bin/createdb -O {UTENTE} dbt3 -p 54322
    ./bin/psql -p 54322 -d dbt3 -f $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/make-dbt3-db_pg.sql
    
  • NOTA: Qui, al posto di {UTENTE}, occorre inserire il proprietario del database.
  1. Si arresti il server:
./bin/pg_ctl -D $PROJECT_HOME/db_data/postgre_s30/ -p 54322 stop

Le istruzioni per preparare il carico di lavoro per il benchmark su facebook-maria1 sono quasi pronte per MariaDB, MySQL e PostgreSQL. Ecco le directory per i vari DBMS, Storage Engine e scale factor che sono pronte in facebook-maria1:

  • ~/benchmark/dbt3/db_data/myisam_s30 dir dei dati per MariaDB/MySQL + MyISAM con scale factor 30
  • ~/benchmark/dbt3/db_data/innodb_mariadb_s30 dir dei dati per MariaDB + InnoDB con scale factor 30 (TODO)
  • ~/benchmark/dbt3/db_data/innodb_mysql_s30 dir dei dati per MySQL + InnoDB con scale factor 30 (TODO)
  • ~/benchmark/dbt3/db_data/postgre_s30 dir dei dati per PostgreSQL con scale factor 30 (TODO)

Preparare il database dei risultati

I risultati del benchmark verranno scritti in un database separato, che verrà eseguito da MariaDB 5.3.x.

NOTA: Il database dei risultati sarà soggetto a modifiche nelle versioni future del progetto DBT3.

Il database viene creato dal file $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/make-results-db.sql. In esso è possibile trovare tutti i dettagli riguardo alle tabelle e alle colonne del database.

Per preparare il database, si seguano queste istruzioni:

  1. Ci si porti nella directory di installazione di MariaDB 5.3.x
    cd $PROJECT_HOME/bin/mariadb-5.3.x-beta-linux-x86_64
    
  1. Si installino le tabelle del database di sistema nella directory dei risultati (per esempio $PROJECT_HOME/db_data/dbt3_results_db)
    ./scripts/mysql_install_db --datadir=$PROJECT_HOME/db_data/dbt3_results_db
    
  1. Si avvii il mysqld del db dei risultati
    ./bin/mysqld_safe --defaults-file=$PROJECT_HOME/mariadb-tools/dbt3_benchmark/config/mariadb_my.cnf --port=12340 --socket=$PROJECT_HOME/temp/mysql_results.sock  --datadir=$PROJECT_HOME/db_data/dbt3_results_db/ &
    
  1. Si installi il database
    ./bin/mysql -u root -P 12340 -S $PROJECT_HOME/temp/mysql_results.sock < $PROJECT_HOME/mariadb-tools/dbt3_benchmark/dbt3_mysql/make-results-db.sql
    
  1. Si arresti il server del db dei risultati:
    ./bin/mysqladmin --user=root --port=12340 --socket=$PROJECT_HOME/temp/mysql_results.sock shutdown 0
    

Script di automazione

Configurare ed eseguire un benchmark

Per poter eseguire un benchmark, occorre avere:

Per ognuna di esse, si troveranno ulteriori dettagli nelle sezioni seguenti.

Ogni benchmark si configura tramite un insieme di file. Quelli di esempio (predefiniti) si trovano sotto la directory 'mariadb-tools/dbt3_benchmark/tests'. Ogni file di configurazione utilizza la sintassi 'ini' e viene letto dallo script di automazione in Perl con il modulo CPAN Config::Auto

Parole chiave della configurazione

Ogni file di configurazione potrebbe contenere delle parole chiave che verranno poi sostituite dallo script con dei valori particolari. Esse possono essere usate per comodità, allo scopo di rendere i file più riutilizzabili all'interno dell'ambiente del benchmark. Queste parole chiave sono:

  • $PROJECT_HOME è la directory in cui si trova il progetto 'mariadb-tools', oppure un percorso base per l'intero progetto (esempio: "DBMS_HOME = $PROJECT_HOME/bin/mariadb-5.3.x-beta-linux-x86_64"). Viene sostituita con il valore del parametro di avvio 'project-home', passato a launcher.pl,
  • $DATADIR_HOME è la directory in cui si trovano le directory dei dati del benchmark (esempio: "$DATADIR_HOME/myisam-s30"). Viene sostituita con il valore del parametro di avvio 'datadir-home', passato a launcher.pl.
  • $QUERIES_HOME è la directory in cui si trovano le query (esempio: "$QUERIES_HOME/s30-m" sono le query per MariaDB/MySQL con scale factor 30). Viene sostituita con il valore del parametro di avvio 'queries-home', passato a launcher.pl.
  • $SCALE_FACTOR è lo scale factor prescelto. Solitamente è parte della directory dei dati (esempio: "$DATADIR_HOME/myisam-s$SCALE_FACTOR"), di quella delle query (esempio: "$QUERIES_HOME/s$SCALE_FACTOR-m") e delle cartella di configurazione del database (esempio: $PROJECT_HOME/mariadb-tools/dbt3_benchmark/config/s$SCALE_FACTOR). Viene sostituita con il valore del parametro di avvio 'scale-factor', passato a launcher.pl.

Si noti che se anche uno solo dei file usa una di queste parole chiave, il parametro corrispondente di launcher.pl diviene obbligatorio.

Configurazione di alto livello

Un file di configurazione di alto livello definisce i percorsi dei di configurazione Test, DBMS, Queries e Results database.

Questi sono i file predefiniti nella directory mariadb-tools/dbt3_benchmark/tests/ e contengono le seguenti impostazioni:

ParameterDescription
RESULTS_DB_CONFIGIl file di configurazione per il DB dei risultati
TEST_CONFIGIl file di configurazione per i test
QUERIES_CONFIGIl file di configurazione per le query
DB_CONFIGIl file di configurazione per per il server del DBMS

Questo file ha il seguente formato:

[common]
RESULTS_DB_CONFIG  = $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/results_db_conf/results_db.conf
TEST_CONFIG        = $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/test_conf/test_myisam.conf

[mariadb_5_3]
QUERIES_CONFIG 	= $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/queries_conf/queries.conf
DB_CONFIG 	= $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/db_conf/db_mariadb_5_3_myisam.conf

[mysql_5_5]
QUERIES_CONFIG 	= $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/queries_conf/queries_mysql.conf
DB_CONFIG 	= $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/db_conf/db_mysql_5_5_myisam.conf
...

NOTA: Le impostazioni RESULTS_DB_CONFIG e TEST_CONFIG devono trovarsi nella sezione [common]. Esse servono all'intero test (debbene alcune impostazioni di TEST_CONFIG possano essere sovrascritte nel file QUERIES_CONFIG). Tutte le impostazioni che combinano QUERIES_CONFIG e DB_CONFIG dovrebbero essere in una sezione separata (esempio: [mariadb_5_3]).

Una configurazione viene passata allo script di configurazione con il parametro --test=/path/to/some_test_configuration.conf (si veda #parametri-di-avvio-dello-script)

Configurazione del server del DBMS

Questi file di configurazioni contengono impostazioni che descrivono il DBMS da testare. Di solito si trovano nella cartella mariadb-tools/dbt3_benchmark/tests/db_conf.

Ecco l'elenco dei parametri che possono essere impostati in questi file di configurazione:

ParametroSpiegazione
DBMS_HOMEPercorso della cartella di installazione di MariaDB / MySQL / PostgreSQL is located.

NOTA: Lo script di automazione usa "./bin/mysqld_safe" per avviare il processo mysqld. Perciò le versioni di MariaDB e MySQL dovrebbero essere "distribuzioni binarie".
DBMS_USERL'utente del database da usare.
CONFIG_FILEIl file di configurazione letto da mysqld o postgres all'avvio
SOCKETIl socket da usare per avviare il server
PORTLa porta su cui il server sarà in ascolto
HOSTL'host in cui si trova il server
DATADIRPercorso della directory dei dati di mysqld o postgres
TMPDIRDove si trovano le tabelle temporanee usate per l'ordinamento e il raggruppamento
DBNAMEIl nome del database (schema) in cui si trovano le tabelle del benchmark
KEYWORDQuesto testo viene scritto nel database dei risultati come parola chiave. Verrà anche usato come nome di una sottocartella contenente risultati e statistiche
DBMSDatabase Management System da usare. Valori ammessi: "MySQL", "MariaDB" e "PostgreSQL"
STORAGE_ENGINELo Storage Engine da usare (MyISAM, InnoDB, etc.)
STARTUP_PARAMSTutti i parametri da usare per avviare il processo mysqld o postgres process. Stesso formato usato nella riga di comando
GRAPH_HEADINGL'heading della grafica di questo test specifico
MYSQL_SYSTEM_DIRSi veda "Nota su MYSQL_SYSTEM_DIR", sotto.
READ_ONLYSe impostato a 1, il processo mysqld viene avviato con il parametro di avvio '--read-only'
PRE_RUN_SQLComandi SQL da eseguire prima di ogni query
POST_RUN_SQLComandi SQL da eseguire dopo ogni query
PRE_TEST_SQLComandi SQL da eseguire prima dell'intero test
POST_TEST_SQLComandi SQL da eseguire dopo l'intero test

Nota su MYSQL_SYSTEM_DIR:

Questa opzione è stata aggiunta per comodità quando si desidera risparmiare tempo e spazio su disco per generare i database per diversi DBMS (e versioni diverse degli stessi) utilizzando un'unica directory dei dati. Quando si eseguono più versioni di MariaDB/MySQL su una singola directory dei dati, bisognerebbe usare mysql-upgrade per aggiustare le tabelle di sistema. Quindi in una directory dei dati, è possibile preparare le seguenti directory per diverse directory di sistema di MariaDB/MySQL:

  • mysql_mysql_5_5 una copia della directory di sistema 'mysql' aggiornata con MySQL 5.5.x
  • mysql_mariadb_5_3 una copia della directory di sistema 'mysql' aggiornata con MariaDB 5.3.x
  • mysql_mariadb_5_5 una copia della directory di sistema 'mysql' aggiornata con MariaDB 5.5.x

Se MYSQL_SYSTEM_DIR è impostato a una di queste directory, lo script di automazione scollegherò l'attuale directory di sistema 'mysql' e creerà un nuovo link simbolico con lo stesso nome della directory impostata.

Ecco un esempio:

unlink /path/to/datadir/mysql
ln -s /path/to/value/in/MYSQL_SYSTEM_DIR/mysql_mariadb_5_3 /path/to/datadir/mysql


NOTA: Questo approccio è adattabile ai test per MyISAM.

Il file di configurazione assomiglia a quanto segue:

[db_settings]
DBMS_HOME	= $PROJECT_HOME/bin/mariadb-5.3.2-beta-linux-x86_64
DBMS_USER	= root
...

Si noti che la sezione [db_settings] è necessaria perché il file venga interpretato correttamente dallo script di automazione.

Configurazione dei test

Questi file di configurazione contengono le impostazioni concernenti i test. Essi si trovano nella directory mariadb-tools/dbt3_benchmark/tests/test_conf.

Ecco un elenco dei parametri che possono essere impostati in questo file:

ParametroSpiegazione
QUERIES_AT_ONCESe è impostato a 1, tutte le query verranno eseguite sequenzialmente senza riavviare il server o svuotare le cache tra le query.
CLEAR_CACHESSe è 1, le cache su disco verranno svuotate prima di testare ogni query.
WARMUPEsegue un riscaldamento prima di lanciare le query.
EXPLAINEsegue un comando Explain prima di ogni query. I risultati vengono scritti in un file nella directory dei risultati.
RUNEsegue il test effettivo.
ANALYZE_EXPLAINUn meccanismo di estrazione dei risultati dove solo il miglior piano di esecuzione (risultati di EXPLAIN select) viene misurato. E' progettato per essere usato con lo Storage Engine InnoDB, laddove il piano scelto varia riavviando il server (si veda #meccanismo-di-estrazione-dei-risultati).
MIN_MAX_OUT_OF_NUn meccanismo di estrazione dei risultati in cui i test del valore minimo e del valore massimo di N (valore del parametro NUM_TESTS) vengono presi come risultato. Questo parametro si può usare quando si testa lo Storage Engine InnoDB (si veda #meccanismo-di-estrazione-dei-risultati).
SIMPLE_AVERAGEUn messanismo di estrazione dei risultati in cui il risultato finale è la media del tempo impiegato dai test. Il numero di test per query è determinato dal parametro NUM_TESTS. Si noti che, se anche un test raggiunge il timeout, il risultato complessivo sarà 'time-out'. Questo parametro si può usare per testare lo Storage Engine MyISAM, perché in questo caso il piano di esecuzione è costante (si veda #meccanismo-di-estrazione-dei-risultati).
NUM_TESTSQuanti test devono essere eseguiti per ogni query. Se ANALYZE_EXPLAIN è impostato, questo valore può essere impostato a 0, che significa che i test devono continuare finché un numero sufficiente di risultati sarà stato estratto (si veda l'impostazione CLUSTER_SIZE). Questo parametro è molto importante se si specifica MIN_MAX_OUT_OF_N o SIMPLE_AVERAGE.
MAX_SKIPPED_TESTSSe ANALYZE_EXPLAIN è impostato e viene scelto il piano di esecuzione più lento, la query non viene eseguita e il server viene riavviato per cambiare piano. Se il server viene riavviato più di MAX_SKIPPED_TESTS volte, è evidente che non ci sono altri piani di esecuzione e lo script passa al benchmark della prossima query.
WARMUPS_COUNTQuante esecuzioni di riscaldamento devono essere eseguite prima del benchmark effettivo.
CLUSTER_SIZEQuanto deve essere grande un cluster con i risultati di una query per estrarre il risultato finale. Si usa insieme al meccanismo di estrazione dei risultati ANALYZE_EXPLAIN.
MAX_QUERY_TIMEQuante volte al massimo una query può essere testata. Attualmente può essere usato solo con ANALYZE_EXPLAIN.
TIMEOUTIl tempo massimo che una query può impiegare. Attualmente è utilizzato solo con MySQL e MariaDB.
OS_STATS_INTERVALIntervallo di tempo che intercorre tra le letture delle statistiche del sistema riguardo alla CPU, la memoria, etc.
PRE_RUN_OSComandi di sistema da eseguire prima di ogni query
POST_RUN_OSComandi di sistema da eseguire dopo ogni query
PRE_TEST_OSComandi di sistema da eseguire prima dell'intero test
POST_TEST_OSComandi di sistema da eseguire dopo il completamento dell'intero test

Il file di configurazione assomiglia a quanto segue:

QUERIES_AT_ONCE = 0
CLEAR_CACHES	= 1
WARMUP		= 0
...

Configurazione delle query

Questi file di configurazione contengono l'elenco di tutte le query da testare su ogni database. Alcune impostazioni della Configurazione del server del DBMS e della Configurazione dei test possono essere sovrascritte nei file della Configurazione delle query. Queste impostazioni si trovano nella directory mariadb-tools/dbt3_benchmark/tests/queries_conf.

Ecco un elenco dei parametri che possono essere impostati in questo file:

ParametroSpiegazione
QUERIES_HOMEDove si trovano le query, sul disco. Questo valore viene concatenato all'opzione QUERY per comporre il percorso delle query. NOTA: Questa impostazione deve trovarsi nella sezione [queries_settings].
CONFIG_FILESovrascrive il parametro di avvio CONFIG_FILE del file di configurazione del server del DMBS e determina il file di configurazione del database da utilizzare. Può essere utilizzata se un file di configurazione privo di ottimizzazioni deve essere impostato come file di configurazione per queste particolari query.

NOTA: Questa impostazione deve trovarsi nella sezione [queries_settings].
QUERYNome della query che si trova nella cartella QUERIES_HOME. Esempio: "1.sql"
EXPLAIN_QUERYNome dell'explain delle query nella cartella QUERIES_HOME. Esempio: "1_explain.sql"
TMPDIRDovrascrive l'impostazione TMPDIR della configurazione del server del DMBS.
STARTUP_PARAMSSovrascrive l'impostazione STARTUP_PARAMS della configurazione del server del DMBS. Utilizzando questa impostazione si possono modificare alcuni particolari parametri (come le ottimizzazioni e i buffer) del server del DB.
PRE_RUN_SQLSovrascrive l'impostazione PRE_RUN_SQL della configurazione del server del DMBS.
POST_RUN_SQLSovrascrive l'impostazione POST_RUN_SQL della configurazione del server del DMBS.
RUNTSovrascrive l'impostazione RUN della configurazione dei test.
EXPLAINSovrascrive l'impostazione EXPLAIN della configurazione dei test.
TIMEOUTSovrascrive l'impostazione TIMEOUT della configurazione dei test.
NUM_TESTSSovrascrive l'impostazione NUM_TESTS della configurazione dei test.
MAX_SKIPPED_TESTSSovrascrive l'impostazione MAX_SKIPPED_TESTS della configurazione dei test.
WARMUPSovrascrive l'impostazione WARMUP della configurazione dei test.
WARMUPS_COUNTSovrascrive l'impostazione WARMUPS_COUNT della configurazione dei test.
MAX_QUERY_TIMESovrascrive l'impostazione MAX_QUERY_TIME della configurazione dei test.
CLUSTER_SIZESovrascrive l'impostazione CLUSTER_SIZE della configurazione dei test.
PRE_RUN_OSSovrascrive l'impostazione PRE_RUN_OS della configurazione dei test.
POST_RUN_OSSovrascrive l'impostazione POST_RUN_OS della configurazione dei test.
OS_STATS_INTERVALSovrascrive l'impostazione OS_STATS_INTERVAL della configurazione dei test.

Il file di configurazione delle query assomiglia a quanto segue:

[queries_settings]
QUERIES_HOME = /percorso/delle/queries

[query1]
QUERY=1.sql
EXPLAIN_QUERY=1_explain.sql
STARTUP_PARAMS=

[query2]
QUERY=2.sql
EXPLAIN_QUERY=2_explain.sql
STARTUP_PARAMS=--optimizer_switch='mrr=on' --mrr_buffer_size=8M --some_startup_parmas
...

...dove "QUERIES_HOME = /percorso/delle/queries" si può sostituire con "QUERIES_HOME = $QUERIES_HOME/s$SCALE_FACTOR-m", nel qual caso $QUERIES_HOME e $SCALE_FACTOR verranno sostituiti dai parametri di avvio passati a launcher.pl (si veda #parametri-di-avvio-dello-script)

NOTA: La sezione [queries_settings] è necessaria perché il file venga interpretato correttamente.Inoltre, le impostazioni di ogni query devono trovarsi in una sezione che ha un nome univoco (esempio: [query1] o [1.sql])

Configurazione del database dei risultati

Questi file di configurazione contengono impostazioni concernenti il database nel quale vengono scritti i risultati. Essi si trovano nella cartella mariadb-tools/dbt3_benchmark/tests/results_db_conf.

Ecco l'elenco dei parametri che possono essere impostati in questo file:

ParametroSpiegazione
DBMS_HOMEPercorso della directory del database. Esempio: "$PROJECT_HOME/mariadb-5.3.x-beta-linux-x86_64". Si dovrebbe usare una distribuzione binaria di MariaDB o MySQL.
DBMS_USERL'utente usato dal DBMS
DATADIRPercorso della directory dei dati del database dei risultati
CONFIG_FILEQuale file di configurazione è usato dal database.
SOCKETIl socket che sarà usato dal database dei risultati. Deve essere differente da quello usato dai database di test.
PORTLa porta usata dal database dei risultati. Deve essere differente da quello usato dai database di test.
STARTUP_PARAMSI parametri di avvio da usare all'avvio del server.
DBNAMEIl nome del database da usare.
HOSTL'host in cui si trova il database dei risultati.

La configurazione del dei risultati assomiglia alla seguente:

DBMS_HOME	= $PROJECT_HOME/mariadb-5.3.x-beta-linux-x86_64
DBMS_USER	= root
...

Parametri di avvio dello script

launcher.pl potrebbe accettare i parametri passati in questo modo: "--some-param". Si noti che queste opzioni sono case-sensitive, cioè le lettere minuscole sono considerate diverse dalle maiuscole. I parametri si scrivono in maiuscolo quando devono sovrascrivere le impostazioni che si trovano in un altro file.

Ecco l'elenco dei parametri di avvio:

ParametroSpiegazione
testIl file di configurazione di alto livello da utilizzare. Questo parametro è obbligatorio.
results-output-dirPercorso dei risultati del benchmark. Un timestamp viene automaticamente aggiunto al nome della directory per poter tenere traccia della data e dell'ora del benchmark. Questo parametro è obbligatorio.
dry-runSe è impostato, non verrà eseguito alcun benchmark. Verranno solo scritti i messaggi sulle operazioni che avrebbero dovuto essere svolte.
project-homeE' obbligatorio se uno dei file di configurazione contiene la variabile '$PROJECT_HOME'. Se tutti i file utilizzano percorsi assoluti, verrà ignorata.
datadir-homeNei file di configurazione, la stringa '$DATADIR_HOME' viene sostituita con questo valore. Se la stringa non c'è, il parametro viene ignorato.
queries-homeNei file di configurazione, la stringa '$QUERIES_HOME' viene sostituita con questo valore. Se la stringa non c'è, il parametro viene ignorato.
scale-factorNei file di configurazione, la stringa '$SCALE_FACTOR' viene sostituita con questo valore. Se la stringa non c'è, il parametro viene ignorato.
CLEAR_CACHESSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
QUERIES_AT_ONCESe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
RUNSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
EXPLAINSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
TIMEOUTSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
NUM_TESTSSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
MAX_SKIPPED_TESTSSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
WARMUPSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
WARMUPS_COUNTSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
MAX_QUERY_TIMESe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
CLUSTER_SIZESe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
PRE_RUN_OSSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
POST_RUN_OSSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.
OS_STATS_INTERVALSe impostato, sovrascrive l'impostazione scritta nel file di configurazione dei test.

Meccanismi di estrazione dei risultati

Esistono tre differenti meccanismi di estrazione dei risultati. Possono essere impostati dai parametri nel file di configurazione dei test:

  • ANALYZE_EXPLAIN
  • MIN_MAX_OUT_OF_N
  • SIMPLE_AVERAGE

Solo uno di questi deve essere impostato a TRUE (1).

ANALYZE_EXPLAIN è utile per il benchmark dello Storage Engine InnoDB, dove il piano di esecuzione di una stessa query potrebbe cambiare al riavvio del server. E' progettato per eseguire la query solo con il piano più performante. Ciò significa che il server viene riavviato se il piano di esecuzione attuale è più lento di un altro. Come risultato finale, viene tenuto quello con il piano di esecuzione che si dimostra essere più veloce ed è stato utilizzato almeno in un numero di test uguale a CLUSTER_SIZE per quella query. Impostando il parametro di configurazione NUM_TESTS si può determinare il numero massimo di esecuzioni dei test, che una volta raggiunto determina il miglior tempo medio del cluster (anche se è minore di CLUSTER_SIZE). Inoltre quando viene raggiunto il timeout di una query (MAX_QUERY_TIME), il meccanismo restituisce il miglior risultato raggiunto dal cluster.

MIN_MAX_OUT_OF_N serve anch'esso per il benchmark dello Storage Engine InnoDB. I tempi dell'esecuzione più rapida e di quella più lenta sono conservati come risultati. Si presume che quando il piano di esecuzione cambia, variano anche i tempi di esecuzione, e interessano soltanto il più lungo e il più breve.

SIMPLE_AVERAGE si usa per il benchmark di quegli Storage Engine che non modificano il piano di esecuzione dopo il riavvio, come MyISAM. Il risultato finale è il tempo di esecuzione media di tutte le esecuzioni delle varie query.

Grafico dei risultati

Dopo l'esecuzione di ogni query, i risultati vengono registrati in un file chiamato results.dat che si trova in {RESULTS_OUTPUT_DIR}. Questo file è progettato per essere letto facilmente dal programma di disegno Gnuplot 4.4. E' diviso in blocchi, separati da molte righe vuote. Tutti i blocchi cominciano con una riga di commento che contiene dettagli sul blocco dei risultati.

Le query che hanno raggiunto il timeout hanno un valore di 100000 in modo che superino il margine del grafico e vengano tagliate fuori. Le altre query sono rappresentate con la loro durata reale (in secondi), che comincia da 0. Il grafico termina l'asse y sul valore più lungo di durata del test + 20%. Per esempio se il test più lungo è durato 100 secondi, il grafico verrà tagliato a 120 secondi. Le query che hanno raggiunto il timeout verranno quindi tagliate a questo limite per rendere l'idea del timeout.

Durante l'esecuzione del test, uno script di gnuplot viene creato con i parametri necessari perché il grafico venga generato automaticamene. Dopo l'esecuzione di ogni singola query il grafico viene rigenerato, in modo che l'utente possa vedere i risultati correnti prima che l'intero benchmark sia finito. Questo file si chiama gnuplot_script.txt e si trova in {RESULTS_OUTPUT_DIR}. L'utente può modificarlo aggiustando i parametri e l'intestazione dopo che il test è completato, per poter dare al risultato finale il "look and feel" desiderato.

Output dello script

Output del benchmark

Nella directory indicata dal parametro {RESULTS_OUTPUT_DIR} (esempio: /benchmark/dbt3/results/myisam_test_2011-12-08_191427/) sono contenuti i seguenti file e directory:

  • Una directory per ogni test, chiamata come il parametro {KEYWORD} della configurazione dei test (esempio: mariadb-5-3-2)
  • cpu_info.txt l'output del comando "/bin/cat /proc/cpuinfo"
  • uname.txt l'output del comando "uname -a"
  • results.dat i risultati dell'esecuzione di ogni query in un solo file. Questo verrà usato come file di dati dallo script di gnuplot. Contiene anche il rapporto tra il primo test e quello corrente.
  • gnuplot_script.txt lo script di Gnuplot che visualizza i grafici.
  • graphics.jpeg il grafico dell'output
  • Un file di configurazione del benchmark (esempio: myisam_test_mariadb_5_3_mysql_5_5_mysql_5_6.conf) copiato da mariadb-tools/dbt3_benchmark/tests/
  • Un file di configurazione del del database dei risultati (esempio: results_db.conf) copiato da mariadb-tools/dbt3_benchmark/tests/results_db_conf/
  • Un file di configurazione dei test (esempio: test_myisam.conf) copiato da mariadb-tools/dbt3_benchmark/tests/test_conf/

Output dei test

La sottodirectory del test specifico, il cui nome corrisponde al valore del parametro {KEYWORD} (esempio: /benchmark/dbt3/results/myisam_test_2011-12-08_191427/mariadb-5-3-2/), contiene i seguenti file:

  • pre_test_os_resutls.txt - l'output dei comandi di sistema (se ci sono) eseguiti prima della prima query del test
  • pre_test_sql_resutls.txt - l'output dei comandi SQL (se ci sono) eseguiti prima della prima query del test
  • post_test_os_resutls.txt - l'output dei comandi di sistema (se ci sono) eseguiti dopo l'ultima query del test
  • post_test_sql_resutls.txt - l'output dei comandi SQL (se ci sono) eseguiti dopo l'ultima query del test
  • all_explains.txt - un file contenente tutti gli EXPlAIN delle query, i loro parametri di avvio per il benchmark e il risultato dell'EXPLAIN
  • Il file config (my.cnf) passato a mysqld o postgres (esempio: mariadb_myisam_my.cnf) copiato da mariadb-tools/dbt3_benchmark/config/s$SCALE_FACTOR/
  • Il file di configurazione delle query (esempio: ''queries-mariadb.conf'') copiato da mariadb-tools/dbt3_benchmark/tests/queries_conf/
  • Il file di configurazione del database (esempio: ''db_mariadb_5_3_myisam.conf'') copiato da mariadb-tools/dbt3_benchmark/tests/db_conf/

Output delle query

Per ogni esecuzione di query, vengono generati diversi file dallo script di automazione. Essi vengono salvati in una sottodirectory il cui nome corrisponde al parametro {KEYWORD}:

  • Risultato explain - un file chiamato '{nome_query}_{numero_esecuzioni}_results.txt' (esempio: '1_explain.sql_1_results.txt' primo test per 1_explain.sql)
  • Comandi di sistema pre-esecuzione - comandi eseguiti prima della query. L'output è un file chiamato 'pre_run_os_q_{nome_query}_no_{numero_esecuzione}_results.txt' (esempio: 'pre_run_os_q_1.sql_no_2_results.txt' secondo test per la query 1.sql)
  • Comandi SQL pre-esecuzione - comandi SQL eseguiti prima della query. L'output è un file chiamato 'pre_run_sql_q_{nome_query}_no_{numero_esecuzione}_results.txt'.
  • Comandi di sistema post-esecuzione - comandi eseguiti dopo la query. L'output è un file chiamato 'post_run_os_q_{nome_query}_no_{numero_esecuzione}_results.txt'.
  • Comandi SQL post-esecuzione - comandi SQL eseguiti dopo la query. L'output è un file chiamato 'post_run_sql_q_{nome_query}_no_{numero_esecuzione}_results.txt'.
  • Statistiche di utilizzo della CPU: '{nome_query}_no_{numero_esecuzione}_sar_u.txt'
  • Statistiche di I/O e velocità di trasferimento: '{nome_query}_no_{numero_esecuzione}_sar_b.txt'
  • Statistiche di utilizzo della memoria: '{nome_query}_no_{numero_esecuzione}_sar_r.txt'

Hook

Lo script di automazione fornisce degli hook che permettono all'utente di aggiungere comandi SQL e di sistema (OS) prima e dopo ogni test. Ecco un elenco di tutti i possibili hook:

  • Hook SQL Pre-test: si imposta con il parametro PRE_TEST_SQL. Contiene comandi SQL da eseguire una sola volta prima della prima esecuzione. (Esempio: "use dbt3; select version(); show variables; show engines; show table status; ")
  • Hook SQL Post-test: si imposta con il parametro POST_TEST_SQL. Contiene comandi SQL da eseguire una sola volta dopo l'ultima esecuzione.
  • Hook OS Pre-test: si imposta con il parametro PRE_TEST_OS. Contiene comandi OS da eseguire una sola volta prima della prima esecuzione.
  • Hook OS Post-test: si imposta con il parametro POST_TEST_OS. Contiene comandi OS da eseguire una sola volta dopo l'ultima esecuzione.
  • Hook SQL Pre-run: si imposta con il parametro PRE_RUN_SQL. Contiene comandi SQL da eseguire prima di ogni singola query. (Esempio: "flush status; set global userstat=on; ")
  • Hook SQL Post-run: si imposta con il parametro POST_RUN_SQL. Contiene comandi SQL da eseguire dopo ogni singola query. (Esempio: "show status; select * from information_schema.TABLE_STATISTICS; ")
  • Hook OS Pre-run: si imposta con il parametro PRE_RUN_OS. Contiene comandi OS da eseguire prima di ogni singola query.
  • Hook SQL Post-run: si imposta con il parametro POST_RUN_OS. Contiene comandi OS da eseguire prima di ogni singola query.

I risultati di questi comandi vengono registrati nella cartella {RESULTS_OUTPUT_DIR}/{KEYWORD} (si veda #loutput-dello-script)

Attività

Ecco le principali attività che vengono eseguite dallo script:

  1. Parsing dei file di configurazione e controllo dei parametri in input - se uno di quelli obbligatori manca, lo script termina con un errore.
  2. Raccolta di informazioni sull'hardware - rilevamento delle informazioni sull'hardware della macchina su cui gira il benchmark. Attualmente raccoglie cpuinfo e uname. I risultati di questi comandi vengono scritti nella directory dei risultati impostata nell'apposito parametro.
  3. Ricerca delle configurazioni dei test positivi

    Per ogni test passato, lo script esegue le seguenti operazioni:
    1. Avvia il server del database dei risultati. I risultati dei test sono scritti in quel database database.
    2. Pulisce le cache sul server

      Questa operazione viene effettuata tramite il seguente comando:
      sudo /sbin/sysctl vm.drop_caches=3
      
      • NOTA: Per pulire le cache l'utente deve disporre dei diritti sudo e occorre aggiungere la seguente riga al file sudoers (per modificarlo: "sudo vusudo"):
        {your_username} ALL=NOPASSWD:/sbin/sysctl
        
    3. Avvio del server del database
    4. Esecuzione dei comandi SQL pre-test. I risultati vengono registrati nella cartella
    5. results_output_dir/{KEYWORD} e il loro nome è pre_test_sql_results.txt. {KEYWORD} è una parola chiave univoca nell'attuale configurazione del database.
    6. Esecuzione dei comandi OS pre-test. I risultati vengono registrati nella cartella results_output_dir/{KEYWORD} e si chiamano pre_test_os_results.txt.
      • NOTA: Se, nella configurazione del test, l'opzione QUERIES_AT_ONCE è impostata a 0, il server viene riavviato tra una query e l'altra. Pertanto i punti 3.2, 3.3, 3.4 e 3.5 vengono eseguiti solo una volta subito prima del punto 3.6.2.
    7. Lettura delle configurazioni delle query, e per ognuna vengono eseguite le seguenti operazioni:
      1. Controllo dei parametri della configurazione del test. Se c'è qualcosa che non va, il programma termina con un errore.
      2. Se è la prima esecuzione della prima query, lettura della versione del server
      3. Esecuzione dei comandi OS nella shell. I risultati di queste query vengono registrati in un file chiamato pre_run_os_q_{QUERY}_no_{RUN_NO}_results.txt nella cartella results_output_dir/{KEYWORD}, dove {QUERY} è il nome della query (esempio: 1.sql), {RUN_NO} è il numero progressivo dell'esecuzione e {KEYWORD} è una parola chiave univoca nella configurazione del test.
      4. Esecuzione delle query SQL pre-run. I risultati di queste query vengono registrati in un file chiamato pre_run_sql_q_{QUERY}_no_{RUN_NO}_results.txt nella cartella results_output_dir/{KEYWORD}, dove {QUERY} è il nome della query (esempio: 1.sql), {RUN_NO} è il numero progressivo dell'esecuzione e {KEYWORD} è una parola chiave univoca nella configurazione del test.
      5. Esecuzioni di riscaldamento, se richieste dal file di configurazione del test
      6. Esecuzione del test effettivo e misurazione della tempistica.
        • Durante questo passaggio, viene creato un nuovo processo figlio per poter rilevare le statistiche del sistema operativo. Attualmente vengono raccolte queste informazioni:
          • Statistiche di utilizzo della CPU. Il comando è:
            sar -u 0 2>null
            
          • Statistiche sulla velocità di trasferimento dell'I/O. Il comando è:
            sar -b 0 2>null
            
          • Statistiche sull'utilizzo della memoria. Il comando è:
            sar -r 0 2>null
            
        • Queste statistiche vengono rilevate ogni N secondi, dove N viene specificato dal parametro della configurazione del test OS_STATS_INTERVAL.
        • L'esecuzione del test su MariaDB e MySQL ha un meccanismo per forzare l'uscita quando viene raggiunto un certo timeout. Esso è controllato dal parametro del test TIMEOUT. Attualmente per PostgreSQL questa funzionalità è assente e dovrebbe essere implementata nelle versioni future.
      7. Esecuzione dell'istruzione "explain" sulla query corrente.
        • NOTA: L'esecuzione delle query EXPLAIN con MySQL prima della versione 5.6.3 potrebbe impiegare molto tempo, perché MySQL deve eseguire l'intera query se vi sono delle SELECT annidate. Per MariaDB e PostgreSQL il problema non esiste. Le query explain che impiegano molto tempo sono le #7, 8, 9, 13 e 15. Per questo motivo in MySQL prima della versione 5.6.3 non dovrebbe essere eseguita alcuna EXPLAIN su queste query.
      8. Esecuzione dei comandi SQL post-run
      9. Esecuzione dei comandi OS post-run nella shell
      10. Log dei risultati nel database dei risultati
      11. Generazione di un grafico dei risultati correnti, tramite Gnuplot
    8. Arresto del server del database.
    9. Esecuzione dei comandi SQL post-test. I risultati vengono registrati nella cartella results_output_dir/{KEYWORD} e si chiamano post_test_sql_results.txt.
    10. Esecuzione dei comandi OS post-test. I risultati vengono registrati nella cartella results_output_dir/{KEYWORD} e si chiamano post_test_os_results.txt.
    11. Arresto del server del database dei risultati

Esempi di chiamate allo script

  • Esempio di chiamata al test per MyISAM con scale factor 30 e timeout di 10 minuti:
    perl launcher.pl \
    --project-home=/path/to/project/home/ \
    --results-output-dir=/path/to/project/home/results/myisam_test \
    --datadir=/path/to/project/home/db_data/ \
    --test=/path/to/project/home/mariadb-tools/dbt3_benchmark/tests/myisam_test_mariadb_5_3_mysql_5_5_mysql_5_6.conf \
    --queries-home=/path/to/project/home/gen_query/ \
    --scale-factor=30 \
    --TIMEOUT=600
    

...dove /path/to/project/home è il percorso del progetto mariadb-tools. Rimpiazza tutte le occorrenze della stringa "$PROJECT_HOME" nel file di configurazione (esempio: "TMPDIR = $PROJECT_HOME/temp/" con "TMPDIR = /path/to/project/home/temp/").

--TIMEOUT sovrascrive il timeout impostato nel file di configurazione, cambiandolo a a 10 minuti.

  • Esempio di test per InnoDB con scale factor 30 con timeout di 2 ore per query e 3 esecuzioni per ogni query:
    perl launcher.pl \
    --project-home=/path/to/project/home/ \
    --results-output-dir=/path/to/project/home/results/innodb_test \
    --datadir=/path/to/project/home/db_data/ \
    --test=/path/to/project/home/mariadb-tools/dbt3_benchmark/tests/innodb_test_mariadb_5_3_mysql_5_5_mysql_5_6.conf \
    --queries-home=/path/to/project/home/gen_query/ \
    --scale-factor=30 \
    --TIMEOUT=7200 \
    --NUM_TESTS=3
    
  • Se esiste una versione più recente di MariaDB 5.5:
    • copiare o modificare il file di configurazione del server del DBMS mariadb-tools/dbt3_benchmark/tests/db_conf/db_mariadb_5_5_myisam.conf e modificare il parametro DBMS_HOME nella distribuzione binaria. E' ache possibile modificare KEYWORD e GRAPH_HEADING
  • Se si desidera aggiungere ulteriori test nel benchmark di MyISAM per MariaDB 5.3, ma con un altro file di configurazione predefinito (my.cnf):
    • copiare o modificare il file di configurazione del server del DBMS mariadb-tools/dbt3_benchmark/tests/db_conf/db_mariadb_5_3_myisam.conf e modificare il parametro CONFIG_FILE in my.cnf
    • copiare o modificare il file di configurazione del test mariadb-tools/dbt3_benchmark/tests/myisam_test_mariadb_5_3_mysql_5_5_mysql_5_6.conf e aggiungere le nuove impostazioni:
      [mariadb_5_3_new_configuration]
      QUERIES_CONFIG = $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/queries_conf/queries-mariadb.conf
      DB_CONFIG 	= $PROJECT_HOME/mariadb-tools/dbt3_benchmark/tests/db_conf/db_mariadb_5_3_myisam_new_configuration.conf
      
  • Se ad esempio si desidera aggiungere ulteriori parametri di avvio per la query 6 per MariaDB:
    • copiare o modificare il file mariadb-tools/dbt3_benchmark/tests/queries_conf/queries-mariadb.conf aggiungendo il parametro: "STARTUP_PARAMS=--optimizer_switch='mrr=on' --mrr_buffer_size=96M" nella sezione della query 6.
    • copiare o modificare il file di configurazione del test mariadb-tools/dbt3_benchmark/tests/myisam_test_mariadb_5_3_mysql_5_5_mysql_5_6.conf per includere il nuovo file di configurazione delle query

Risultati

Test di MyISAM

Benchmark DBT3 con la seguente configurazione:

Pagina dei risultati: DBT3 benchmark results MyISAM

Test di InnoDB

Benchmark DBT3 con la seguente configurazione:

Pagina dei risultati: DBT3 benchmark results InnoDB

Test di PostgreSQL

Benchmark DBT3 con la seguente configurazione:

Pagina dei risultati: (TODO)

Commenti

Sto caricando i commenti......
Content reproduced on this site is the property of its respective owners, and this content is not reviewed in advance by MariaDB. The views, information and opinions expressed by this content do not necessarily represent those of MariaDB or any other party.