~drizzle-trunk/drizzle/development

 

   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

 

 

/*

 

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

  then reporting the timing of each stage.

 

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

     the test with. (single client)

  2) Load test (many clients)

 

  Examples:

 

  querying (200 selects for each):

 

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

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

 

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

  schema and data):

 

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

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

  with five clients (five times each):

 

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

              --delimiter=";"

 

#include <sys/wait.h>

#include <ctype.h>

 

static char *shared_memory_base_name=0;

#endif

 

            *default_engine= NULL,

            *pre_system= NULL,

            *post_system= NULL,

 

const char *delimiter= "\n";

 

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_char_cols_index= 0;

static unsigned int iterations;

static uint my_end_arg= 0;

const char *opt_csv_str;

File csv_file;

 

 

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

 

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

 

};

 

static option_string *engine_options= NULL;

static statement *create_statements= NULL;

 

static statement **query_statements= NULL;

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

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

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

uint 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 drop_primary_key_list(void);

                         option_string *engine_stmt, stats *sptr);

                         uint64_t limit);

pthread_handler_t run_task(void *p);

pthread_handler_t timer_thread(void *p);

void statement_cleanup(statement *stmt);

void option_cleanup(option_string *stmt);

void standard_deviation (conclusions *con, stats *sptr);

 

static const char ALPHANUMERICS[]=

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;

 

int main(int argc, char **argv)

{

  option_string *eptr;

  unsigned int x;

 

 

  MY_INIT(argv[0]);

 

      fprintf(stderr, "This application was compiled incorrectly. Please recompile with thread support.\n");

 

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

    exit(1);

  }

 

 

  VOID(pthread_mutex_init(&counter_mutex, NULL));

  VOID(pthread_cond_init(&count_threshhold, NULL));

    if (*concurrency)

    {

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

    }

    else

    {

      uint infinite= 1;

      do {

      }

      while (infinite++);

    }

 

    if (!opt_preserve)

 

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

  if (opt_burnin)

    goto burnin;

 

  VOID(pthread_mutex_destroy(&timer_alarm_mutex));

  VOID(pthread_cond_destroy(&timer_alarm_threshold));

 

 

  /* now free all the strings we created */

  if (opt_password)

  return 0;

}

 

{

  unsigned int x;

  stats *head_sptr;

  conclusions conclusion;

  unsigned long long client_limit;

 

                                MYF(MY_ZEROFILL|MY_FAE|MY_WME));

 

  bzero(&conclusion, sizeof(conclusions));

      data in the table.

    */

    if (opt_preserve == false)

 

    /* First we create */

    if (create_statements)

 

    /*

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

    if (verbose >= 2)

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

    if (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary)

 

    if (commit_rate)

 

    if (pre_system)

      system(pre_system);

 

    */

    if (pre_statements)

 

    if (post_statements)

 

    if (post_system)

      system(post_system);

    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,

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

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

    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,

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

  {"auto-generate-sql-execute-number", OPT_SLAP_AUTO_GENERATE_EXECUTE_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,

    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},

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

    (char**) &auto_generate_sql_secondary_indexes, 0,

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

    OPT_SLAP_AUTO_GENERATE_UNIQUE_QUERY_NUM,

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

    (char**) &auto_generate_sql_unique_query_number,

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

    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,

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

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

  {"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 erros in query run.",

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

    0, 0, 0},

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

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

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

  {"csv", OPT_SLAP_CSV,

    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},

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

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

  {"delimiter", 'F',

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

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

  {"detach", OPT_SLAP_DETACH,

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

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

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

    (char**) &default_engine, (char**) &default_engine, 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 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 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,

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

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

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

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

    (char**) &num_of_query, (char**) &num_of_query, 0,

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

      "out what it would have done instead.",

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

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

  {"password", 'p',

    "Password to use when connecting to server. If password is not given it's "

      "asked from the tty.", 0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

    0},

  {"post-query", OPT_SLAP_POST_QUERY,

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

    (char**) &user_supplied_post_statements,

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

  {"post-system", OPT_SLAP_POST_SYSTEM,

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

    (char**) &post_system,

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

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

    (char**) &user_supplied_pre_statements,

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

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

    (char**) &pre_system,

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

    "The protocol of connection (tcp,socket,pipe,memory).",

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

  {"query", 'q', "Query to run or file containing query to run.",

    (char**) &user_supplied_query, (char**) &user_supplied_query,

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

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

    (char**)&opt_set_random_seed,

    (char**)&opt_set_random_seed,0,

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

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

  {"socket", 'S', "Socket file to use for connection.",

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

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

#ifndef DONT_ALLOW_USER_CHANGE

  {"user", 'u', "User for login if not current user.", (char**) &user,

#endif

  {"verbose", 'v',

    "More verbose output; you can use this multiple times to get even more "

      GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,

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

static void usage(void)

{

  print_version();

  puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\

       \nand you are welcome to modify and redistribute it under the GPL \

       license\n");

      char *start= argument;

      my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));

      opt_password= my_strdup(argument,MYF(MY_FAE));

      if (*start)

      tty_password= 0;

    }

    else

    exit(0);

    break;

  case '?':

    usage();

    exit(0);

  }

      if (count) /* Except for the first pass we add a comma */

        dynstr_append(&table_string, ",");

 

          > HUGE_STRING_LENGTH)

      {

        fprintf(stderr, "Memory Allocation error in create table\n");

    {

      if (num_int_cols_index)

      {

                     col_count, col_count) > HUGE_STRING_LENGTH)

        {

          fprintf(stderr, "Memory Allocation error in create table\n");

      }

      else

      {

            > HUGE_STRING_LENGTH)

        {

          fprintf(stderr, "Memory Allocation error in create table\n");

    {

      if (num_char_cols_index)

      {

                     col_count, col_count) > HUGE_STRING_LENGTH)

        {

          fprintf(stderr, "Memory Allocation error in creating table\n");

      }

      else

      {

                     col_count) > HUGE_STRING_LENGTH)

        {

          fprintf(stderr, "Memory Allocation error in creating table\n");

  if (num_blob_cols)

    for (col_count= 1; col_count <= num_blob_cols; col_count++)

    {

                   col_count) > HUGE_STRING_LENGTH)

      {

        fprintf(stderr, "Memory Allocation error in creating table\n");

    }

 

  dynstr_append(&table_string, ")");

                              MYF(MY_ZEROFILL|MY_FAE|MY_WME));

  ptr->string = (char *)my_malloc(table_string.length+1,

                                  MYF(MY_ZEROFILL|MY_FAE|MY_WME));

  if (num_int_cols)

    for (col_count= 1; col_count <= num_int_cols; col_count++)

    {

                   random()) > HUGE_STRING_LENGTH)

      {

        fprintf(stderr, "Memory Allocation error in creating update\n");

      char rand_buffer[RAND_STRING_SIZE];

      int buf_len= get_random_string(rand_buffer, RAND_STRING_SIZE);

 

          > HUGE_STRING_LENGTH)

      {

        fprintf(stderr, "Memory Allocation error in creating update\n");

    dynstr_append(&update_string, " WHERE id = ");

 

 

                              MYF(MY_ZEROFILL|MY_FAE|MY_WME));

 

  ptr->string= (char *)my_malloc(update_string.length + 1,

      unsigned int size;

      unsigned int difference= num_blob_cols_size - num_blob_cols_size_min;

 

                          num_blob_cols_size;

 

      buf_len= get_random_string(blob_ptr, size);

  {

    for (col_count= 1; col_count <= num_int_cols; col_count++)

    {

          > HUGE_STRING_LENGTH)

      {

        fprintf(stderr, "Memory Allocation error in creating select\n");

  }

  dynstr_append(&query_string, " FROM t1");

 

      (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary))

    dynstr_append(&query_string, " WHERE id = ");

 

  ptr->string= (char *)my_malloc(query_string.length + 1,

                              MYF(MY_ZEROFILL|MY_FAE|MY_WME));

  ptr->length= query_string.length+1;

      (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary))

    ptr->type= SELECT_TYPE_REQUIRES_PREFIX;

  else

      exit(1);

  }

 

      auto_generate_sql_autoincrement)

  {

      fprintf(stderr,

  if (opt_csv_str)

  {

    opt_silent= true;

    if (opt_csv_str[0] == '-')

    {

      csv_file= fileno(stdout);

      printf("Building Create Statements for Auto\n");

 

    create_statements= build_table_string();

    */

         x++, ptr_statement= ptr_statement->next)

    {

      ptr_statement->next= build_insert_string();

    if (!opt_auto_generate_sql_type)

      opt_auto_generate_sql_type= "mixed";

 

      parse_option(opt_auto_generate_sql_type, &query_options, ',');

 

    query_statements= (statement **)my_malloc(sizeof(statement *) * query_statements_count,

          printf("Generating SELECT Statements for Auto\n");

 

        query_statements[sql_type_count]= build_select_string(false);

             x++, ptr_statement= ptr_statement->next)

        {

          ptr_statement->next= build_select_string(false);

        }

 

        query_statements[sql_type_count]= build_select_string(true);

             x++, ptr_statement= ptr_statement->next)

        {

          ptr_statement->next= build_select_string(true);

      else if (sql_type->string[0] == 'w')

      {

        /*

          Archive (since strings which were identical one after another

          would be too easily optimized).

        */

        if (verbose >= 2)

          printf("Generating INSERT Statements for Auto\n");

        query_statements[sql_type_count]= build_insert_string();

             x++, ptr_statement= ptr_statement->next)

        {

          ptr_statement->next= build_insert_string();

        }

 

        query_statements[sql_type_count]= build_update_string();

             x++, ptr_statement= ptr_statement->next)

        {

          ptr_statement->next= build_update_string();

        int coin= 0;

 

        query_statements[sql_type_count]= build_insert_string();

          This logic should be extended to do a more mixed load,

          at the moment it results in "every other".

        */

             x++, ptr_statement= ptr_statement->next)

        {

          if (coin)

    /* Set this up till we fully support options on user generated queries */

    if (user_supplied_query)

    {

        parse_option("default", &query_options, ',');

 

      query_statements= (statement **)my_malloc(sizeof(statement *),

        actual_queries= parse_delimiter(tmp_string, &query_statements[0],

                                        delimiter[0]);

      my_free(tmp_string, MYF(0));

    else if (user_supplied_query)

    {

      actual_queries= parse_delimiter(user_supplied_query, &query_statements[0],

      (void)parse_delimiter(tmp_string, &pre_statements,

                            delimiter[0]);

    my_free(tmp_string, MYF(0));

  else if (user_supplied_pre_statements)

  {

    (void)parse_delimiter(user_supplied_pre_statements,

      (void)parse_delimiter(tmp_string, &post_statements,

                            delimiter[0]);

    my_free(tmp_string, MYF(0));

  else if (user_supplied_post_statements)

  {

    (void)parse_delimiter(user_supplied_post_statements, &post_statements,

}

 

 

{

  if (opt_only_print)

  {

 

  if (verbose >= 3)

    printf("%.*s;\n", len, query);

}

 

 

static int

{

  unsigned long long counter;

 

 

    of the server during load runs.

  */

                         strstr(engine_stmt->string, "blackhole")))

  {

    primary_keys_number_of= 1;

                                    MYF(MY_ZEROFILL|MY_FAE|MY_WME));

    /* Yes, we strdup a const string to simplify the interface */

  }

  else

  {

    {

      fprintf(stderr,"%s: Cannot select GUID primary keys. (%s)\n", my_progname,

      exit(1);

    }

 

 

    /* So why check this? Blackhole :) */

    if (primary_keys_number_of)

      /*

        We create the structure and loop and create the items.

      */

                                       MYF(MY_ZEROFILL|MY_FAE|MY_WME));

        primary_keys[counter]= my_strdup(row[0], MYF(0));

    }

 

  }

 

  return(0);

}

 

static int

              option_string *engine_stmt, stats *sptr)

{

  char query[HUGE_STRING_LENGTH];

  if (verbose >= 2)

    printf("Loading Pre-data\n");

 

  {

    fprintf(stderr,"%s: Cannot create schema %s : %s\n", my_progname, db,

    exit(1);

  }

  else

    if (verbose >= 3)

      printf("%s;\n", query);

 

    {

      fprintf(stderr,"%s: Cannot select schema '%s': %s\n",my_progname, db,

      exit(1);

    }

    sptr->create_count++;

  {

    len= snprintf(query, HUGE_STRING_LENGTH, "set storage_engine=`%s`",

                  engine_stmt->string);

    {

      fprintf(stderr,"%s: Cannot set default engine: %s\n", my_progname,

      exit(1);

    }

    sptr->create_count++;

    {

      char buffer[HUGE_STRING_LENGTH];

 

               engine_stmt->option);

      {

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

        if (!opt_ignore_sql_errors)

          exit(1);

      }

    }

    else

    {

      {

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

        if (!opt_ignore_sql_errors)

          exit(1);

      }

}

 

static int

{

  char query[HUGE_STRING_LENGTH];

  int len;

 

  len= snprintf(query, HUGE_STRING_LENGTH, "DROP SCHEMA IF EXISTS `%s`", db);

 

  {

    fprintf(stderr,"%s: Cannot drop database '%s' ERROR : %s\n",

    exit(1);

  }

 

}

 

static int

{

  statement *ptr;

 

 

  for (ptr= stmt; ptr && ptr->length; ptr= ptr->next)

  {

    {

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

      exit(1);

    }

    if (!opt_only_print)

    {

      {

      }

    }

  }

 

  pthread_attr_init(&attr);

  pthread_attr_setdetachstate(&attr,

 

  pthread_mutex_lock(&counter_mutex);

  thread_counter= 0;

 

  real_concurrency= 0;

 

       y++, sql_type= sql_type->next)

  {

    unsigned int options_loop= 1;

 

    if (sql_type->option)

    {

                           (char **)NULL, 10);

      options_loop= options_loop ? options_loop : 1;

    }

 

        real_concurrency++;

        /* now you create the thread */

                           (void *)con) != 0)

        {

          fprintf(stderr,"%s: Could not create thread\n", my_progname);

      }

  }

 

    call that run tasks obey.

  */

  if (opt_timer_length)

    timer_alarm= true;

    pthread_mutex_unlock(&timer_alarm_mutex);

 

                       (void *)&opt_timer_length) != 0)

    {

      fprintf(stderr,"%s: Could not create timer thread\n", my_progname);

 

 

 

  {

            my_progname);

    exit(1);

  }

 

    also keeps the value properly syncronized across call threads.

  */

  pthread_mutex_lock(&sleeper_mutex);

  timer_alarm= false;

  pthread_mutex_unlock(&timer_alarm_mutex);

 

  return(0);

}

 

  uint64_t counter= 0, queries;

  uint64_t detach_counter;

  unsigned int commit_counter;

  statement *ptr;

  thread_context *con= (thread_context *)p;

 

  {

            my_progname);

    exit(1);

  }

  }

  pthread_mutex_unlock(&sleeper_mutex);

 

 

  if (verbose >= 3)

    printf("connected!\n");

 

  commit_counter= 0;

  if (commit_rate)

 

limit_not_met:

         ptr= ptr->next, detach_counter++)

    {

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

      {

      }

 

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

      */

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

        char *key;

        char buffer[HUGE_STRING_LENGTH];

 

          This should only happen if some sort of new engine was

          implemented that didn't properly handle UPDATEs.

 

 

          assert(key);

 

                           (int)ptr->length, ptr->string, key);

 

          {

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

            exit(1);

          }

        }

      }

      else

      {

        {

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

          exit(1);

        }

      }

      {

        do

        {

          {

              counter++;

          }

      }

      queries++;

 

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

      {

        commit_counter= 0;

      }

 

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

 

end:

  if (commit_rate)

 

 

  pthread_mutex_lock(&counter_mutex);

  thread_counter--;

 

  my_free(con, MYF(0));

 

  return(0);

}

 

 

    bzero(buffer, HUGE_STRING_LENGTH);

 

 

    if (string)

    {

 

  for (tmp= *sptr= (statement *)my_malloc(sizeof(statement),

                                          MYF(MY_ZEROFILL|MY_FAE|MY_WME));

       tmp->next=  (statement *)my_malloc(sizeof(statement),

                                          MYF(MY_ZEROFILL|MY_FAE|MY_WME)),

       tmp= tmp->next)

 

  if (ptr != script+length)

  {

                                       MYF(MY_FAE));

    tmp->length= (size_t)((script + length) - ptr);

    count++;

 

  for (;*ptr; ptr++)

    if (*ptr == ',') count++;

  /* One extra spot for the NULL */

                                  MYF(MY_ZEROFILL|MY_FAE|MY_WME));

 

  ptr= (char *)string;

         con->min_timing / 1000, con->min_timing % 1000);

  printf("\tMaximum number of seconds to run all queries: %ld.%03ld seconds\n",

         con->max_timing / 1000, con->max_timing % 1000);

         con->sum_of_time / 1000, con->sum_of_time % 1000);

  printf("\tStandard Deviation: %ld.%03ld\n", con->std_dev / 1000, con->std_dev % 1000);

  printf("\tNumber of queries in create queries: %llu\n", con->create_count);

         con->users, con->real_users);

  printf("\tNumber of times test was run: %u\n", iterations);

  printf("\n");

}

 

      else

        label_buffer[x]= opt_label[x] ;

    }

  else if (opt_auto_generate_sql_type)

  {

    string_len= strlen(opt_auto_generate_sql_type);

  else

    snprintf(label_buffer, HUGE_STRING_LENGTH, "query");

 

           "%s,%s,%ld.%03ld,%ld.%03ld,%ld.%03ld,%ld.%03ld,%ld.%03ld,%u,%u,%u,%llu\n",

           con->engine ? con->engine : "", /* Storage engine we ran against */

           label_buffer, /* Load type */

  stats *ptr;

  unsigned int x;

 

  con->max_timing= sptr->timing;

  con->min_rows= sptr->rows;

  con->max_rows= sptr->rows;

  /* At the moment we assume uniform */

  con->users= sptr->users;

  con->real_users= sptr->real_users;

  con->avg_rows= sptr->rows;

  /* With no next, we know it is the last element that was malloced */

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

  {

  standard_deviation(con, sptr);

 

  /* Now we do the create time operations */

  con->create_max_timing= sptr->create_timing;

  /* At the moment we assume uniform */

  con->create_count= sptr->create_count;

  /* With no next, we know it is the last element that was malloced */

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

  {

  {

    nptr= ptr->next;

    if (ptr->string)

    if (ptr->option)

    my_free(ptr, MYF(0));

  }

}

  {

    nptr= ptr->next;

    if (ptr->string)

    my_free(ptr, MYF(0));

  }

}

 

{

    return;

 

}

 

{

  /* Connect to server */

  static ulong connection_retry_sleep= 100000; /* Microseconds */

  int x, connect_error= 1;

 

    return;

 

  if (opt_delayed_start)

    my_sleep(random()%opt_delayed_start);

 

 

  if (opt_compress)

  /* We always do opt_protocol to TCP/IP */

 

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

  {

 

 

                           connect_to_schema ? create_schema_string : NULL,

                           connect_flags))

    {

      /* Connect suceeded */

  if (connect_error)

  {

    fprintf(stderr,"%s: Error when connecting to server: %d %s\n",

    exit(1);

  }

 

  return;

}

 

standard_deviation (conclusions *con, stats *sptr)

{

  unsigned int x;