~drizzle-trunk/drizzle/development

/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2010 Vijay Samuel

 *  Copyright (C) 2008 MySQL

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

/*

  Drizzle Slap

  A simple program designed to work as if multiple clients querying the database,

  then reporting the timing of each stage.

  Drizzle slap runs three stages:

  1) Create schema,table, and optionally any SP or data you want to beign

  the test with. (single client)

  2) Load test (many clients)

  3) Cleanup (disconnection, drop table if specified, single client)

  Examples:

  Supply your own create and query SQL statements, with 50 clients

  querying (200 selects for each):

  drizzleslap --delimiter=";" \

  --create="CREATE TABLE A (a int);INSERT INTO A VALUES (23)" \

  --query="SELECT * FROM A" --concurrency=50 --iterations=200

  Let the program build the query SQL statement with a table of two int

  columns, three varchar columns, five clients querying (20 times each),

  don't create the table or insert the data (using the previous test's

  schema and data):

  drizzleslap --concurrency=5 --iterations=20 \

  --number-int-cols=2 --number-char-cols=3 \

  --auto-generate-sql

  Tell the program to load the create, insert and query SQL statements from

  the specified files, where the create.sql file has multiple table creation

  statements delimited by ';' and multiple insert statements delimited by ';'.

  The --query file will have multiple queries delimited by ';', run all the

  load statements, and then run all the queries in the query file

  with five clients (five times each):

  drizzleslap --concurrency=5 \

  --iterations=5 --query=query.sql --create=create.sql \

  --delimiter=";"

  @todo

  Add language for better tests

  String length for files and those put on the command line are not

  setup to handle binary data.

  More stats

  Break up tests and run them on multiple hosts at once.

  Allow output to be fed into a database directly.

*/

#include "config.h"

#include "client_priv.h"

#include "option_string.h"

#include "stats.h"

#include "thread_context.h"

#include "conclusions.h"

#include "wakeup.h"

#include <signal.h>

#include <stdarg.h>

#include <sys/types.h>

#include <sys/wait.h>

#ifdef HAVE_SYS_STAT_H

# include <sys/stat.h>

#endif

#include <fcntl.h>

#include <math.h>

#include <cassert>

#include <cstdlib>

#include <string>

#include <iostream>

#include <fstream>

#include <drizzled/configmake.h>

/* Added this for string translation. */

#include <drizzled/gettext.h>

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/condition_variable.hpp>

#include <boost/program_options.hpp>

#include <drizzled/atomics.h>

#define SLAP_VERSION "1.5"

#define HUGE_STRING_LENGTH 8196

#define RAND_STRING_SIZE 126

#define DEFAULT_BLOB_SIZE 1024

using namespace std;

using namespace drizzled;

namespace po= boost::program_options;

#ifdef HAVE_SMEM

static char *shared_memory_base_name=0;

#endif

/* Global Thread counter */

uint32_t thread_counter;

boost::mutex counter_mutex;

boost::condition_variable_any count_threshhold;

client::Wakeup master_wakeup;

/* Global Thread timer */

static bool timer_alarm= false;

boost::mutex timer_alarm_mutex;

boost::condition_variable_any timer_alarm_threshold;

std::vector < std::string > primary_keys;

drizzled::atomic<size_t> connection_count;

static string host, 

  opt_password, 

  user,

  user_supplied_query,

  user_supplied_pre_statements,

  user_supplied_post_statements,

  default_engine,

  pre_system,

  post_system;

static vector<string> user_supplied_queries;

static string opt_verbose;

std::string opt_protocol;

string delimiter;

string create_schema_string;

static bool use_drizzle_protocol= false;

static bool opt_preserve= true;

static bool opt_only_print;

static bool opt_burnin;

static bool opt_ignore_sql_errors= false;

static bool opt_silent,

  auto_generate_sql_autoincrement,

  auto_generate_sql_guid_primary,

  auto_generate_sql;

std::string opt_auto_generate_sql_type;

static int32_t verbose= 0;

static uint32_t delimiter_length;

static uint32_t commit_rate;

static uint32_t detach_rate;

static uint32_t opt_timer_length;

static uint32_t opt_delayed_start;

string num_blob_cols_opt,

  num_char_cols_opt,

  num_int_cols_opt;

string opt_label;

static uint32_t opt_set_random_seed;

string auto_generate_selected_columns_opt;

/* Yes, we do set defaults here */

static uint32_t num_int_cols= 1;

static uint32_t num_char_cols= 1;

static uint32_t num_blob_cols= 0;

static uint32_t num_blob_cols_size;

static uint32_t num_blob_cols_size_min;

static uint32_t num_int_cols_index= 0;

static uint32_t num_char_cols_index= 0;

static uint32_t iterations;

static uint64_t actual_queries= 0;

static uint64_t auto_actual_queries;

static uint64_t auto_generate_sql_unique_write_number;

static uint64_t auto_generate_sql_unique_query_number;

static uint32_t auto_generate_sql_secondary_indexes;

static uint64_t num_of_query;

static uint64_t auto_generate_sql_number;

string concurrency_str;

string create_string;

std::vector <uint32_t> concurrency;

std::string opt_csv_str;

int csv_file;

static int process_options(void);

static uint32_t opt_drizzle_port= 0;

static OptionString *engine_options= NULL;

static OptionString *query_options= NULL;

static Statement *pre_statements= NULL;

static Statement *post_statements= NULL;

static Statement *create_statements= NULL;

static std::vector <Statement *> query_statements;

static uint32_t query_statements_count;

/* Prototypes */

void print_conclusions(Conclusions &con);

void print_conclusions_csv(Conclusions &con);

void generate_stats(Conclusions *con, OptionString *eng, Stats *sptr);

uint32_t parse_comma(const char *string, std::vector <uint32_t> &range);

uint32_t parse_delimiter(const char *script, Statement **stmt, char delm);

uint32_t parse_option(const char *origin, OptionString **stmt, char delm);

static void drop_schema(drizzle_con_st &con, const char *db);

uint32_t get_random_string(char *buf, size_t size);

static Statement *build_table_string(void);

static Statement *build_insert_string(void);

static Statement *build_update_string(void);

static Statement * build_select_string(bool key);

static int generate_primary_key_list(drizzle_con_st &con, OptionString *engine_stmt);

static void create_schema(drizzle_con_st &con, const char *db, Statement *stmt, OptionString *engine_stmt, Stats *sptr);

static void run_scheduler(Stats *sptr, Statement **stmts, uint32_t concur, uint64_t limit);

void statement_cleanup(Statement *stmt);

void option_cleanup(OptionString *stmt);

void concurrency_loop(drizzle_con_st &con, uint32_t current, OptionString *eptr);

static void run_statements(drizzle_con_st &con, Statement *stmt);

void slap_connect(drizzle_con_st &con, bool connect_to_schema);

void slap_close(drizzle_con_st &con);

static int run_query(drizzle_con_st &con, drizzle_result_st *result, const char *query, int len);

void standard_deviation(Conclusions &con, Stats *sptr);

static const char ALPHANUMERICS[]=

"0123456789ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstuvwxyz";

#define ALPHANUMERICS_SIZE (sizeof(ALPHANUMERICS)-1)

static long int timedif(struct timeval a, struct timeval b)

{

  register int us, s;

  us = a.tv_usec - b.tv_usec;

  us /= 1000;

  s = a.tv_sec - b.tv_sec;

  s *= 1000;

  return s + us;

}

static void combine_queries(vector<string> queries)

{

  user_supplied_query.erase();

  for (vector<string>::iterator it= queries.begin();

       it != queries.end();

       ++it)

  {

    user_supplied_query.append(*it);

    user_supplied_query.append(delimiter);

  }

}

static void run_task(ThreadContext *ctx)

{

  uint64_t counter= 0, queries;

  uint64_t detach_counter;

  uint32_t commit_counter;

  drizzle_con_st con;

  drizzle_result_st result;

  drizzle_row_t row;

  Statement *ptr;

  master_wakeup.wait();

  slap_connect(con, true);

  if (verbose >= 3)

    printf("connected!\n");

  queries= 0;

  commit_counter= 0;

  if (commit_rate)

    run_query(con, NULL, "SET AUTOCOMMIT=0", strlen("SET AUTOCOMMIT=0"));

limit_not_met:

  for (ptr= ctx->getStmt(), detach_counter= 0;

       ptr && ptr->getLength();

       ptr= ptr->getNext(), detach_counter++)

  {

    if (not opt_only_print && detach_rate && !(detach_counter % detach_rate))

    {

      slap_close(con);

      slap_connect(con, true);

    }

    /*

      We have to execute differently based on query type. This should become a function.

    */

    if ((ptr->getType() == UPDATE_TYPE_REQUIRES_PREFIX) ||

        (ptr->getType() == SELECT_TYPE_REQUIRES_PREFIX))

    {

      int length;

      uint32_t key_val;

      char buffer[HUGE_STRING_LENGTH];

      /*

        This should only happen if some sort of new engine was

        implemented that didn't properly handle UPDATEs.

        Just in case someone runs this under an experimental engine we don't

        want a crash so the if() is placed here.

      */

      assert(primary_keys.size());

      if (primary_keys.size())

      {

        key_val= (uint32_t)(random() % primary_keys.size());

        const char *key;

        key= primary_keys[key_val].c_str();

        assert(key);

        length= snprintf(buffer, HUGE_STRING_LENGTH, "%.*s '%s'",

                         (int)ptr->getLength(), ptr->getString(), key);

        if (run_query(con, &result, buffer, length))

        {

          fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

                  internal::my_progname, (uint32_t)length, buffer, drizzle_con_error(&con));

          abort();

        }

      }

    }

    else

    {

      if (run_query(con, &result, ptr->getString(), ptr->getLength()))

      {

        fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

                internal::my_progname, (uint32_t)ptr->getLength(), ptr->getString(), drizzle_con_error(&con));

        abort();

      }

    }

    if (not opt_only_print)

    {

      while ((row = drizzle_row_next(&result)))

        counter++;

      drizzle_result_free(&result);

    }

    queries++;

    if (commit_rate && (++commit_counter == commit_rate))

    {

      commit_counter= 0;

      run_query(con, NULL, "COMMIT", strlen("COMMIT"));

    }

    /* If the timer is set, and the alarm is not active then end */

    if (opt_timer_length && timer_alarm == false)

      goto end;

    /* If limit has been reached, and we are not in a timer_alarm just end */

    if (ctx->getLimit() && queries == ctx->getLimit() && timer_alarm == false)

      goto end;

  }

  if (opt_timer_length && timer_alarm == true)

    goto limit_not_met;

  if (ctx->getLimit() && queries < ctx->getLimit())

    goto limit_not_met;

end:

  if (commit_rate)

    run_query(con, NULL, "COMMIT", strlen("COMMIT"));

  slap_close(con);

  {

    boost::mutex::scoped_lock scopedLock(counter_mutex);

    thread_counter--;

    count_threshhold.notify_one();

  }

  delete ctx;

}

/**

 * commandline_options is the set of all options that can only be called via the command line.

 * client_options is the set of all options that can be defined via both command line and via

 * the configuration file client.cnf

 * slap_options is the set of all drizzleslap specific options which behave in a manner 

 * similar to that of client_options. It's configuration file is drizzleslap.cnf

 * long_options is the union of commandline_options, slap_options and client_options.

 * There are two configuration files per set of options, one which is defined by the user

 * which is found at either $XDG_CONFIG_HOME/drizzle or ~/.config/drizzle directory and the other which 

 * is the system configuration file which is found in the SYSCONFDIR/drizzle directory.

 * The system configuration file is over ridden by the user's configuration file which

 * in turn is over ridden by the command line.

 */

int main(int argc, char **argv)

{

  char *password= NULL;

  try

  {

    po::options_description commandline_options("Options used only in command line");

    commandline_options.add_options()

      ("help,?","Display this help and exit")

      ("info,i","Gives information and exit")

      ("burnin",po::value<bool>(&opt_burnin)->default_value(false)->zero_tokens(),

       "Run full test case in infinite loop")

      ("ignore-sql-errors", po::value<bool>(&opt_ignore_sql_errors)->default_value(false)->zero_tokens(),

       "Ignore SQL errors in query run")

      ("create-schema",po::value<string>(&create_schema_string)->default_value("drizzleslap"),

       "Schema to run tests in")

      ("create",po::value<string>(&create_string)->default_value(""),

       "File or string to use to create tables")

      ("detach",po::value<uint32_t>(&detach_rate)->default_value(0),

       "Detach (close and re open) connections after X number of requests")

      ("iterations,i",po::value<uint32_t>(&iterations)->default_value(1),

       "Number of times to run the tests")

      ("label",po::value<string>(&opt_label)->default_value(""),

       "Label to use for print and csv")

      ("number-blob-cols",po::value<string>(&num_blob_cols_opt)->default_value(""),

       "Number of BLOB columns to create table with if specifying --auto-generate-sql. Example --number-blob-cols=3:1024/2048 would give you 3 blobs with a random size between 1024 and 2048. ")

      ("number-char-cols,x",po::value<string>(&num_char_cols_opt)->default_value(""),

       "Number of VARCHAR columns to create in table if specifying --auto-generate-sql.")

      ("number-int-cols,y",po::value<string>(&num_int_cols_opt)->default_value(""),

       "Number of INT columns to create in table if specifying --auto-generate-sql.")

      ("number-of-queries",

       po::value<uint64_t>(&num_of_query)->default_value(0),

       "Limit each client to this number of queries(this is not exact)") 

      ("only-print",po::value<bool>(&opt_only_print)->default_value(false)->zero_tokens(),

       "This causes drizzleslap to not connect to the database instead print out what it would have done instead")

      ("post-query", po::value<string>(&user_supplied_post_statements)->default_value(""),

       "Query to run or file containing query to execute after tests have completed.")

      ("post-system",po::value<string>(&post_system)->default_value(""),

       "system() string to execute after tests have completed")

      ("pre-query",

       po::value<string>(&user_supplied_pre_statements)->default_value(""),

       "Query to run or file containing query to execute before running tests.")

      ("pre-system",po::value<string>(&pre_system)->default_value(""),

       "system() string to execute before running tests.")

      ("query,q",po::value<vector<string> >(&user_supplied_queries)->composing()->notifier(&combine_queries),

       "Query to run or file containing query")

      ("verbose,v", po::value<string>(&opt_verbose)->default_value("v"), "Increase verbosity level by one.")

      ("version,V","Output version information and exit") 

      ;

    po::options_description slap_options("Options specific to drizzleslap");

    slap_options.add_options()

      ("auto-generate-sql-select-columns",

       po::value<string>(&auto_generate_selected_columns_opt)->default_value(""),

       "Provide a string to use for the select fields used in auto tests")

      ("auto-generate-sql,a",po::value<bool>(&auto_generate_sql)->default_value(false)->zero_tokens(),

       "Generate SQL where not supplied by file or command line")  

      ("auto-generate-sql-add-autoincrement",

       po::value<bool>(&auto_generate_sql_autoincrement)->default_value(false)->zero_tokens(),

       "Add an AUTO_INCREMENT column to auto-generated tables")

      ("auto-generate-sql-execute-number",

       po::value<uint64_t>(&auto_actual_queries)->default_value(0),

       "See this number and generate a set of queries to run")

      ("auto-generate-sql-guid-primary",

       po::value<bool>(&auto_generate_sql_guid_primary)->default_value(false)->zero_tokens(),

       "Add GUID based primary keys to auto-generated tables")

      ("auto-generate-sql-load-type",

       po::value<string>(&opt_auto_generate_sql_type)->default_value("mixed"),

       "Specify test load type: mixed, update, write, key or read; default is mixed")  

      ("auto-generate-sql-secondary-indexes",

       po::value<uint32_t>(&auto_generate_sql_secondary_indexes)->default_value(0),

       "Number of secondary indexes to add to auto-generated tables")

      ("auto-generated-sql-unique-query-number",

       po::value<uint64_t>(&auto_generate_sql_unique_query_number)->default_value(10),

       "Number of unique queries to generate for automatic tests")

      ("auto-generate-sql-unique-write-number",

       po::value<uint64_t>(&auto_generate_sql_unique_write_number)->default_value(10),

       "Number of unique queries to generate for auto-generate-sql-write-number")

      ("auto-generate-sql-write-number",

       po::value<uint64_t>(&auto_generate_sql_number)->default_value(100),

       "Number of row inserts to perform for each thread (default is 100).")

      ("commit",po::value<uint32_t>(&commit_rate)->default_value(0),

       "Commit records every X number of statements")

      ("concurrency,c",po::value<string>(&concurrency_str)->default_value(""),

       "Number of clients to simulate for query to run")

      ("csv",po::value<std::string>(&opt_csv_str)->default_value(""),

       "Generate CSV output to named file or to stdout if no file is name.")

      ("delayed-start",po::value<uint32_t>(&opt_delayed_start)->default_value(0),

       "Delay the startup of threads by a random number of microsends (the maximum of the delay")

      ("delimiter,F",po::value<string>(&delimiter)->default_value("\n"),

       "Delimiter to use in SQL statements supplied in file or command line")

      ("engine,e",po::value<string>(&default_engine)->default_value(""),

       "Storage engine to use for creating the table")

      ("set-random-seed",

       po::value<uint32_t>(&opt_set_random_seed)->default_value(0), 

       "Seed for random number generator (srandom(3)) ") 

      ("silent,s",po::value<bool>(&opt_silent)->default_value(false)->zero_tokens(),

       "Run program in silent mode - no output. ") 

      ("timer-length",po::value<uint32_t>(&opt_timer_length)->default_value(0),

       "Require drizzleslap to run each specific test a certain amount of time in seconds")  

      ;

    po::options_description client_options("Options specific to the client");

    client_options.add_options()

      ("host,h",po::value<string>(&host)->default_value("localhost"),"Connect to the host")

      ("password,P",po::value<char *>(&password),

       "Password to use when connecting to server. If password is not given it's asked from the tty")

      ("port,p",po::value<uint32_t>(), "Port number to use for connection")

      ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),

       "The protocol of connection (mysql or drizzle).")

      ("user,u",po::value<string>(&user)->default_value(""),

       "User for login if not current user")  

      ;

    po::options_description long_options("Allowed Options");

    long_options.add(commandline_options).add(slap_options).add(client_options);

    std::string system_config_dir_slap(SYSCONFDIR); 

    system_config_dir_slap.append("/drizzle/drizzleslap.cnf");

    std::string system_config_dir_client(SYSCONFDIR); 

    system_config_dir_client.append("/drizzle/client.cnf");

    std::string user_config_dir((getenv("XDG_CONFIG_HOME")? getenv("XDG_CONFIG_HOME"):"~/.config"));

    uint64_t temp_drizzle_port= 0;

    drizzle_con_st con;

    OptionString *eptr;

    // Disable allow_guessing

    int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

    po::variables_map vm;

    po::store(po::command_line_parser(argc, argv).options(long_options).

              style(style).extra_parser(parse_password_arg).run(), vm);

    std::string user_config_dir_slap(user_config_dir);

    user_config_dir_slap.append("/drizzle/drizzleslap.cnf"); 

    std::string user_config_dir_client(user_config_dir);

    user_config_dir_client.append("/drizzle/client.cnf");

    ifstream user_slap_ifs(user_config_dir_slap.c_str());

    po::store(parse_config_file(user_slap_ifs, slap_options), vm);

    ifstream user_client_ifs(user_config_dir_client.c_str());

    po::store(parse_config_file(user_client_ifs, client_options), vm);

    ifstream system_slap_ifs(system_config_dir_slap.c_str());

    store(parse_config_file(system_slap_ifs, slap_options), vm);

    ifstream system_client_ifs(system_config_dir_client.c_str());

    store(parse_config_file(system_client_ifs, client_options), vm);

    po::notify(vm);

    if (process_options())

      abort();

    if ( vm.count("help") || vm.count("info"))

    {

      printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",internal::my_progname, SLAP_VERSION,

          drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);

      puts("Copyright (C) 2008 Sun Microsystems");

      puts("This software comes with ABSOLUTELY NO WARRANTY. "

           "This is free software,\n"

           "and you are welcome to modify and redistribute it under the GPL "

           "license\n");

      puts("Run a query multiple times against the server\n");

      cout << long_options << endl;

      abort();

    }   

    if (vm.count("protocol"))

    {

      std::transform(opt_protocol.begin(), opt_protocol.end(),

        opt_protocol.begin(), ::tolower);

      if (not opt_protocol.compare("mysql"))

        use_drizzle_protocol=false;

      else if (not opt_protocol.compare("drizzle"))

        use_drizzle_protocol=true;

      else

      {

        cout << _("Error: Unknown protocol") << " '" << opt_protocol << "'" << endl;

        abort();

      }

    }

    if (vm.count("port")) 

    {

      temp_drizzle_port= vm["port"].as<uint32_t>();

      if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))

      {

        fprintf(stderr, _("Value supplied for port is not valid.\n"));

        abort();

      }

      else

      {

        opt_drizzle_port= (uint32_t) temp_drizzle_port;

      }

    }

  if ( vm.count("password") )

  {

    if (not opt_password.empty())

      opt_password.erase();

    if (password == PASSWORD_SENTINEL)

    {

      opt_password= "";

    }

    else

    {

      opt_password= password;

      tty_password= false;

    }

  }

  else

  {

      tty_password= true;

  }

    if ( vm.count("version") )

    {

      printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",internal::my_progname, SLAP_VERSION,

          drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);

      abort();

    }

    /* Seed the random number generator if we will be using it. */

    if (auto_generate_sql)

    {

      if (opt_set_random_seed == 0)

        opt_set_random_seed= (uint32_t)time(NULL);

      srandom(opt_set_random_seed);

    }

    /* globals? Yes, so we only have to run strlen once */

    delimiter_length= delimiter.length();

    slap_connect(con, false);

    /* Main iterations loop */

burnin:

    eptr= engine_options;

    do

    {

      /* For the final stage we run whatever queries we were asked to run */

      uint32_t *current;

      if (verbose >= 2)

        printf("Starting Concurrency Test\n");

      if (concurrency.size())

      {