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.

2. Power test
   • Esegue 22 query complesse.

3. 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:

• Perl
  • Home del progetto: http://www.perl.org/

• mariadb-tools
  • Home del progetto: https://launchpad.net/mariadb-tools
  • La cartella del progetto si chiama "dbt3_benchmark" ed è sotto mariadb-tools.

• dbt3-1.9
  • Download: http://sourceforge.net/projects/osdldbt/files/dbt3/

• Gnuplot 4.4 — programma per l'output grafico.
  • Home del progetto: http://www.gnuplot.info/

• 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

2. 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
   

3. Si esegua make per compilare DBD::mysql:

   make
   

4. 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

• MySQL 5.5.x
  • Download: http://dev.mysql.com/downloads/mysql/#downloads → Generally Available (GA) Releases → Linux - Generic 2.6 (x86, 64-bit), Compressed TAR Archive - scaricare mysql-5.5.x-linux2.6-x86_64.tar.gz - file tag gzippato per Linux x86

• MySQL 5.6.x
  • Download: http://dev.mysql.com/downloads/mysql/#downloads → Development Releases → Linux - Generic 2.6 (x86, 64-bit), Compressed TAR Archive - scaricare mysql-5.6.x-m5-linux2.6-x86_64.tar.gz - file tag gzippato per Linux x86

• MariaDB 5.3.x
  • Download: https://launchpad.net/maria/5.3 , scaricato con Bazaar:

    bzr branch lp:maria/5.3
    

• MariaDB 5.5.x
  • Download: https://launchpad.net/maria/5.5 , scaricato con Bazaar:

    bzr branch lp:maria/5.5
    

• PostgreSQL
  • Download: http://www.postgresql.org/ftp/source/v9.1rc1/

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/

2. Scaricare l'archivio di DBT3 1.9 nella cartella del progetto $PROJECT_HOME

3. Decomprimere l'archivio nella cartella del progetto

   cd $PROJECT_HOME
   tar -zxf dbt3-1.9.tar.gz
   

4. 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/
   

5. 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/
  

6. Recarsi in $PROJECT_HOME/dbt3-1.9/src/dbgen e si compili il progetto

   cd $PROJECT_HOME/dbt3-1.9/src/dbgen
   make
   

7. 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/
      

8. Creare una directory che conterrà le query così generate, in

   mkdir $PROJECT_HOME/gen_query
   

9. Generare le query

• 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
  

10. 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.

11. Creare una directory per il workload da generare

    mkdir $PROJECT_HOME/gen_data/s30
    

12. 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/
    

13. 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/

2. 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/

2. 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
   

2. Si compili MariaDB

   cd mariadb-5.3/
   ./BUILD/compile-amd64-max
   

3. Si crei un file tar.gz

   ./scripts/make_binary_distribution
   

4. 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 '|';
  

2. 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.

3. 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.

4. 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.

5. 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/

2. Si scarichi il file tramite il link postgresql-9.1rc1.tar.gz

3. Si scompatti l'archivio nella cartella del progetto

   gunzip < postgresql-9.1rc1.tar.gz |tar xf -
   

4. 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

5. 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
   

6. Si avvii il server:

   ./bin/postgres -D $PROJECT_HOME/db_data/postgre_s30 -p 54322 &
   

7. 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.

8. 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
   

2. 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
   

3. 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/ &
   

4. 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
   

5. 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:

• 5 file di configurazione:
  1. Configurazione del DBMS (si veda #dbms-server-configuration)
  2. Configurazione dei Test (si veda #test-configuration)
  3. Configurazione delle Query (si veda #queries-configuration)
  4. Configurazione del Database dei Risultati (si veda #results-database-configuration)
  5. File delle configurazione di Alto Livello che combina quanto elencato sopra (si veda #top-level-configuration)
• uno script di automazione launcher.plche dovrebbe trovarsi in mariadb-tools/dbt3_benchmark/
• parametri di avvio che dovrebbero essere passati allo script di automazione (si veda #script-startup-parameters).

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:

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:

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

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:

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:

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:

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:

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:

• MariaDB 5.3.2 Beta + MyISAM
• MariaDB 5.5.18 + MyISAM
• MySQL 5.5.19 + MyISAM
• MySQL 5.6.4 + MyISAM

Pagina dei risultati: DBT3 benchmark results MyISAM

Test di InnoDB

Benchmark DBT3 con la seguente configurazione:

• MariaDB 5.3.2 Beta + XtraDB
• MariaDB 5.5.18 + XtraDB
• MySQL 5.5.19 + InnoDB
• MySQL 5.6.4 + InnoDB

Pagina dei risultati: DBT3 benchmark results InnoDB

Test di PostgreSQL

Benchmark DBT3 con la seguente configurazione:

• MariaDB 5.3.2 Beta + XtraDB
• MySQL 5.6.4 + InnoDB
• PostgreSQL

Pagina dei risultati: (TODO)