~drizzle-trunk/drizzle/development

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

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

 *

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

*/

#define SLAP_VERSION "1.5"

#define HUGE_STRING_LENGTH 8196

#define RAND_STRING_SIZE 126

#define DEFAULT_BLOB_SIZE 1024

#include "client_priv.h"

#include <signal.h>

#include <stdarg.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <ctype.h>

#include <string>

/* Added this for string translation. */

#include <drizzled/gettext.h>

using namespace std;

#ifdef HAVE_SMEM

static char *shared_memory_base_name=0;

#endif

extern "C"

bool get_one_option(int optid, const struct my_option *, char *argument);

/* Global Thread counter */

uint32_t thread_counter;

pthread_mutex_t counter_mutex;

pthread_cond_t count_threshhold;

uint32_t master_wakeup;

pthread_mutex_t sleeper_mutex;

pthread_cond_t sleep_threshhold;

/* Global Thread timer */

static bool timer_alarm= false;

pthread_mutex_t timer_alarm_mutex;

pthread_cond_t timer_alarm_threshold;

static char **defaults_argv;

char **primary_keys;

/* This gets passed to malloc, so lets set it to an arch-dependant size */

size_t primary_keys_number_of;

static char *host= NULL, *opt_password= NULL, *user= NULL,

  *user_supplied_query= NULL,

  *user_supplied_pre_statements= NULL,

  *user_supplied_post_statements= NULL,

  *default_engine= NULL,

  *pre_system= NULL,

  *post_system= NULL,

  *opt_drizzle_unix_port= NULL;

const char *delimiter= "\n";

const char *create_schema_string= "drizzleslap";

static bool opt_preserve= true;

static bool debug_info_flag= false, debug_check_flag= false;

static bool opt_only_print= false;

static bool opt_burnin= false;

static bool opt_ignore_sql_errors= false;

static bool opt_compress= false, tty_password= false,

  opt_silent= false,

  auto_generate_sql_autoincrement= false,

  auto_generate_sql_guid_primary= false,

  auto_generate_sql= false;

const char *opt_auto_generate_sql_type= "mixed";

static int verbose, delimiter_length;

static uint32_t commit_rate;

static uint32_t detach_rate;

static uint32_t opt_timer_length;

static uint32_t opt_delayed_start;

const char *num_int_cols_opt;

const char *num_char_cols_opt;

const char *num_blob_cols_opt;

const char *opt_label;

static unsigned int opt_set_random_seed;

const char *auto_generate_selected_columns_opt;

/* Yes, we do set defaults here */

static unsigned int num_int_cols= 1;

static unsigned int num_char_cols= 1;

static unsigned int num_blob_cols= 0;

static unsigned int num_blob_cols_size;

static unsigned int num_blob_cols_size_min;

static unsigned int num_int_cols_index= 0;

static unsigned int num_char_cols_index= 0;

static unsigned int iterations;

static uint32_t my_end_arg= 0;

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 unsigned int auto_generate_sql_secondary_indexes;

static uint64_t num_of_query;

static uint64_t auto_generate_sql_number;

const char *concurrency_str= NULL;

static char *create_string;

uint32_t *concurrency;

const char *default_dbug_option= "d:t:o,/tmp/drizzleslap.trace";

const char *opt_csv_str;

File csv_file;

static int get_options(int *argc,char ***argv);

static uint32_t opt_drizzle_port= 0;

static const char *load_default_groups[]= { "drizzleslap","client",0 };

/* Types */

typedef enum {

  SELECT_TYPE= 0,

  UPDATE_TYPE= 1,

  INSERT_TYPE= 2,

  UPDATE_TYPE_REQUIRES_PREFIX= 3,

  CREATE_TABLE_TYPE= 4,

  SELECT_TYPE_REQUIRES_PREFIX= 5,

  DELETE_TYPE_REQUIRES_PREFIX= 6

} slap_query_type;

typedef struct statement statement;

struct statement {

  char *string;

  size_t length;

  slap_query_type type;

  char *option;

  size_t option_length;

  statement *next;

};

typedef struct option_string option_string;

struct option_string {

  char *string;

  size_t length;

  char *option;

  size_t option_length;

  option_string *next;

};

typedef struct stats stats;

struct stats {

  long int timing;

  uint32_t users;

  uint32_t real_users;

  uint64_t rows;

  long int create_timing;

  uint64_t create_count;

};

typedef struct thread_context thread_context;

struct thread_context {

  statement *stmt;

  uint64_t limit;

};

typedef struct conclusions conclusions;

struct conclusions {

  char *engine;

  long int avg_timing;

  long int max_timing;

  long int min_timing;

  uint32_t users;

  uint32_t real_users;

  uint64_t avg_rows;

  long int sum_of_time;

  long int std_dev;

  /* These are just for create time stats */

  long int create_avg_timing;

  long int create_max_timing;

  long int create_min_timing;

  uint64_t create_count;

  /* The following are not used yet */

  uint64_t max_rows;

  uint64_t min_rows;

};

static option_string *engine_options= NULL;

static option_string *query_options= NULL;

static statement *pre_statements= NULL;

static statement *post_statements= NULL;

static statement *create_statements= NULL;

static statement **query_statements= NULL;

static unsigned int query_statements_count;

/* Prototypes */

void print_conclusions(conclusions *con);

void print_conclusions_csv(conclusions *con);

void generate_stats(conclusions *con, option_string *eng, stats *sptr);

uint32_t parse_comma(const char *string, uint32_t **range);

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

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

static int 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, option_string *engine_stmt);

static int drop_primary_key_list(void);

static int create_schema(drizzle_con_st *con, const char *db, statement *stmt,

                         option_string *engine_stmt, stats *sptr);

static int run_scheduler(stats *sptr, statement **stmts, uint32_t concur,

                         uint64_t limit);

extern "C" pthread_handler_t run_task(void *p);

extern "C" pthread_handler_t timer_thread(void *p);

void statement_cleanup(statement *stmt);

void option_cleanup(option_string *stmt);

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

static int 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;

}

int main(int argc, char **argv)

{

  drizzle_con_st con;

  option_string *eptr;

  unsigned int x;

  my_init();

  MY_INIT(argv[0]);

  load_defaults("drizzle",load_default_groups,&argc,&argv);

  defaults_argv=argv;

  if (get_options(&argc,&argv))

  {

    free_defaults(defaults_argv);

    my_end(0);

    exit(1);

  }

  /* 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= (unsigned int)time(NULL);

    srandom(opt_set_random_seed);

  }

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

  delimiter_length= strlen(delimiter);

  if (argc > 2)

  {

    fprintf(stderr,"%s: Too many arguments\n",my_progname);

    free_defaults(defaults_argv);

    my_end(0);

    exit(1);

  }

  slap_connect(&con, false);

  pthread_mutex_init(&counter_mutex, NULL);

  pthread_cond_init(&count_threshhold, NULL);

  pthread_mutex_init(&sleeper_mutex, NULL);

  pthread_cond_init(&sleep_threshhold, NULL);

  pthread_mutex_init(&timer_alarm_mutex, NULL);

  pthread_cond_init(&timer_alarm_threshold, NULL);

  /* 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)

    {

      for (current= concurrency; current && *current; current++)

        concurrency_loop(&con, *current, eptr);

    }

    else

    {

      uint32_t infinite= 1;

      do {

        concurrency_loop(&con, infinite, eptr);

      }

      while (infinite++);

    }

    if (!opt_preserve)

      drop_schema(&con, create_schema_string);

  } while (eptr ? (eptr= eptr->next) : 0);

  if (opt_burnin)

    goto burnin;

  pthread_mutex_destroy(&counter_mutex);

  pthread_cond_destroy(&count_threshhold);

  pthread_mutex_destroy(&sleeper_mutex);

  pthread_cond_destroy(&sleep_threshhold);

  pthread_mutex_destroy(&timer_alarm_mutex);

  pthread_cond_destroy(&timer_alarm_threshold);

  slap_close(&con);

  /* now free all the strings we created */

  if (opt_password)

    free(opt_password);

  free(concurrency);

  statement_cleanup(create_statements);

  for (x= 0; x < query_statements_count; x++)

    statement_cleanup(query_statements[x]);

  free(query_statements);

  statement_cleanup(pre_statements);

  statement_cleanup(post_statements);

  option_cleanup(engine_options);

  option_cleanup(query_options);

#ifdef HAVE_SMEM

  if (shared_memory_base_name)

    free(shared_memory_base_name);

#endif

  free_defaults(defaults_argv);

  my_end(my_end_arg);

  return 0;

}

void concurrency_loop(drizzle_con_st *con, uint32_t current, option_string *eptr)

{

  unsigned int x;

  stats *head_sptr;

  stats *sptr;

  conclusions conclusion;

  uint64_t client_limit;

  head_sptr= (stats *)malloc(sizeof(stats) * iterations);

  if (head_sptr == NULL)

  {

    fprintf(stderr,"Error allocating memory in concurrency_loop\n");

    exit(1);

  }

  memset(head_sptr, 0, sizeof(stats) * iterations);

  memset(&conclusion, 0, sizeof(conclusions));

  if (auto_actual_queries)

    client_limit= auto_actual_queries;

  else if (num_of_query)

    client_limit=  num_of_query / current;

  else

    client_limit= actual_queries;

  for (x= 0, sptr= head_sptr; x < iterations; x++, sptr++)

  {

    /*

      We might not want to load any data, such as when we are calling

      a stored_procedure that doesn't use data, or we know we already have

      data in the table.

    */

    if (opt_preserve == false)

      drop_schema(con, create_schema_string);

    /* First we create */

    if (create_statements)

      create_schema(con, create_schema_string, create_statements, eptr, sptr);

    /*

      If we generated GUID we need to build a list of them from creation that

      we can later use.

    */

    if (verbose >= 2)

      printf("Generating primary key list\n");

    if (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary)

      generate_primary_key_list(con, eptr);

    if (commit_rate)

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

    if (pre_system)

    {

      int ret= system(pre_system);

      assert(ret != -1);

    }

    /*

      Pre statements are always run after all other logic so they can

      correct/adjust any item that they want.

    */

    if (pre_statements)

      run_statements(con, pre_statements);

    run_scheduler(sptr, query_statements, current, client_limit);

    if (post_statements)

      run_statements(con, post_statements);

    if (post_system)

    {

      int ret=  system(post_system);

      assert(ret !=-1);

    }

    /* We are finished with this run */

    if (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary)

      drop_primary_key_list();

  }

  if (verbose >= 2)

    printf("Generating stats\n");

  generate_stats(&conclusion, eptr, head_sptr);

  if (!opt_silent)

    print_conclusions(&conclusion);

  if (opt_csv_str)

    print_conclusions_csv(&conclusion);

  free(head_sptr);

}

static struct my_option my_long_options[] =

{

  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,

   0, 0, 0, 0, 0, 0},

  {"auto-generate-sql-select-columns", OPT_SLAP_AUTO_GENERATE_SELECT_COLUMNS,

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

   (char**) &auto_generate_selected_columns_opt,

   (char**) &auto_generate_selected_columns_opt,

   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"auto-generate-sql", 'a',

   "Generate SQL where not supplied by file or command line.",

   (char**) &auto_generate_sql, (char**) &auto_generate_sql,

   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"auto-generate-sql-add-autoincrement", OPT_SLAP_AUTO_GENERATE_ADD_AUTO,

   "Add an AUTO_INCREMENT column to auto-generated tables.",

   (char**) &auto_generate_sql_autoincrement,

   (char**) &auto_generate_sql_autoincrement,

   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"auto-generate-sql-execute-number", OPT_SLAP_AUTO_GENERATE_EXECUTE_QUERIES,

   "Set this number to generate a set number of queries to run.",

   (char**) &auto_actual_queries, (char**) &auto_actual_queries,

   0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"auto-generate-sql-guid-primary", OPT_SLAP_AUTO_GENERATE_GUID_PRIMARY,

   "Add GUID based primary keys to auto-generated tables.",

   (char**) &auto_generate_sql_guid_primary,

   (char**) &auto_generate_sql_guid_primary,

   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"auto-generate-sql-load-type", OPT_SLAP_AUTO_GENERATE_SQL_LOAD_TYPE,

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

   (char**) &opt_auto_generate_sql_type, (char**) &opt_auto_generate_sql_type,

   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

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

   OPT_SLAP_AUTO_GENERATE_SECONDARY_INDEXES,

   "Number of secondary indexes to add to auto-generated tables.",

   (char**) &auto_generate_sql_secondary_indexes,

   (char**) &auto_generate_sql_secondary_indexes, 0,

   GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"auto-generate-sql-unique-query-number",

   OPT_SLAP_AUTO_GENERATE_UNIQUE_QUERY_NUM,

   "Number of unique queries to generate for automatic tests.",

   (char**) &auto_generate_sql_unique_query_number,

   (char**) &auto_generate_sql_unique_query_number,

   0, GET_ULL, REQUIRED_ARG, 10, 0, 0, 0, 0, 0},

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

   OPT_SLAP_AUTO_GENERATE_UNIQUE_WRITE_NUM,

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

   (char**) &auto_generate_sql_unique_write_number,

   (char**) &auto_generate_sql_unique_write_number,

   0, GET_ULL, REQUIRED_ARG, 10, 0, 0, 0, 0, 0},

  {"auto-generate-sql-write-number", OPT_SLAP_AUTO_GENERATE_WRITE_NUM,

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

   (char**) &auto_generate_sql_number, (char**) &auto_generate_sql_number,

   0, GET_ULL, REQUIRED_ARG, 100, 0, 0, 0, 0, 0},

  {"burnin", OPT_SLAP_BURNIN, "Run full test case in infinite loop.",

   (char**) &opt_burnin, (char**) &opt_burnin, 0, GET_BOOL, NO_ARG, 0, 0, 0,

   0, 0, 0},

  {"ignore-sql-errors", OPT_SLAP_IGNORE_SQL_ERRORS,

   "Ignore SQL erros in query run.",

   (char**) &opt_ignore_sql_errors,

   (char**) &opt_ignore_sql_errors,

   0, GET_BOOL, NO_ARG, 0, 0, 0,

   0, 0, 0},

  {"commit", OPT_SLAP_COMMIT, "Commit records every X number of statements.",

   (char**) &commit_rate, (char**) &commit_rate, 0, GET_UINT, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"compress", 'C', "Use compression in server/client protocol.",

   (char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,

   0, 0, 0},

  {"concurrency", 'c', "Number of clients to simulate for query to run.",

   (char**) &concurrency_str, (char**) &concurrency_str, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"create", OPT_SLAP_CREATE_STRING, "File or string to use create tables.",

   (char**) &create_string, (char**) &create_string, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"create-schema", OPT_CREATE_SLAP_SCHEMA, "Schema to run tests in.",

   (char**) &create_schema_string, (char**) &create_schema_string, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"csv", OPT_SLAP_CSV,

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

   (char**) &opt_csv_str, (char**) &opt_csv_str, 0, GET_STR,

   OPT_ARG, 0, 0, 0, 0, 0, 0},

  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",

    (char**) &debug_check_flag, (char**) &debug_check_flag, 0,

    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"debug-info", 'T', "Print some debug info at exit.", (char**) &debug_info_flag,

    (char**) &debug_info_flag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"delayed-start", OPT_SLAP_DELAYED_START,

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

   (char**) &opt_delayed_start, (char**) &opt_delayed_start, 0, GET_UINT,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"delimiter", 'F',

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

   (char**) &delimiter, (char**) &delimiter, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"detach", OPT_SLAP_DETACH,

   "Detach (close and reopen) connections after X number of requests.",

   (char**) &detach_rate, (char**) &detach_rate, 0, GET_UINT, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"engine", 'e', "Storage engine to use for creating the table.",

   (char**) &default_engine, (char**) &default_engine, 0,

   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"host", 'h', "Connect to host.", (char**) &host, (char**) &host, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"iterations", 'i', "Number of times to run the tests.", (char**) &iterations,

   (char**) &iterations, 0, GET_UINT, REQUIRED_ARG, 1, 0, 0, 0, 0, 0},

  {"label", OPT_SLAP_LABEL, "Label to use for print and csv output.",

   (char**) &opt_label, (char**) &opt_label, 0,

   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"number-blob-cols", OPT_SLAP_BLOB_COL,

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

   (char**) &num_blob_cols_opt, (char**) &num_blob_cols_opt, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"number-char-cols", 'x',

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

   (char**) &num_char_cols_opt, (char**) &num_char_cols_opt, 0, GET_STR, REQUIRED_ARG,