Merge bk-internal:/home/bk/mysql-4.0/

into serg.mylan:/usr/home/serg/Abk/mysql-4.0

include/my_sys.h

@@ -749,6 +749,7 @@ extern my_bool my_uncompress(byte *, ulong *, ulong *);
 extern byte *my_compress_alloc(const byte *packet, ulong *len, ulong *complen);
 extern ulong checksum(const byte *mem, uint count);
 extern uint my_bit_log2(ulong value);
+uint my_count_bits(ulonglong v);
 extern void my_sleep(ulong m_seconds);
 
 #ifdef __WIN__

myisam/mi_check.c

@@ -2246,7 +2246,17 @@ int mi_repair_parallel(MI_CHECK *param, register MI_INFO *info,
   else
     rec_length=share->base.pack_reclength;
   sort_info.max_records=
-    ((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records :
+  /* +1 below is required hack for parallel repair mode.
+     The info->state->records value, that is compared later
+     to sort_info.max_records and cannot exceed it, is
+     increased in sort_key_write. In mi_repair_by_sort, sort_key_write
+     is called after sort_key_read, where the comparison is performed,
+     but in parallel mode master thread can call sort_key_write
+     before some other repair thread calls sort_key_read.
+     Furthermore I'm not even sure +1 would be enough.
+     May be sort_info.max_records shold be always set to max value in
+     parallel mode. */
+    ((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records + 1:
      (ha_rows) (sort_info.filelength/rec_length+1));
 
   del=info->state->del;

mysys/my_bit.c

@@ -29,3 +29,45 @@ uint my_bit_log2(ulong value)
   for (bit=0 ; value > 1 ; value>>=1, bit++) ;
   return bit;
 }
+
+static char nbits[256] = {
+  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
+};
+
+uint my_count_bits(ulonglong v)
+{
+#if SIZEOF_LONG_LONG > 4
+  /* The following code is a bit faster on 16 bit machines than if we would
+     only shift v */
+  ulong v2=(ulong) (v >> 32);
+  return (uint) (uchar) (nbits[(uchar)  v] +
+                         nbits[(uchar) (v >> 8)] +
+                         nbits[(uchar) (v >> 16)] +
+                         nbits[(uchar) (v >> 24)] +
+                         nbits[(uchar) (v2)] +
+                         nbits[(uchar) (v2 >> 8)] +
+                         nbits[(uchar) (v2 >> 16)] +
+                         nbits[(uchar) (v2 >> 24)]);
+#else
+  return (uint) (uchar) (nbits[(uchar)  v] +
+                         nbits[(uchar) (v >> 8)] +
+                         nbits[(uchar) (v >> 16)] +
+                         nbits[(uchar) (v >> 24)]);
+#endif
+}
+

sql/ha_myisam.cc

@@ -579,11 +579,25 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
     {
       local_testflag|= T_STATISTICS;
       param.testflag|= T_STATISTICS;		// We get this for free
-      thd->proc_info="Repair by sorting";
       statistics_done=1;
+      if (current_thd->variables.myisam_repair_threads>1)
+      {
+        char buf[40];
+        /* TODO: respect myisam_repair_threads variable */
+        my_snprintf(buf, 40, "Repair with %d threads", my_count_bits(key_map));
+        thd->proc_info=buf;
+        error = mi_repair_parallel(&param, file, fixed_name,
+            param.testflag & T_QUICK);
+        thd->proc_info="Repair done"; // to reset proc_info, as
+                                      // it was pointing to local buffer
+      }
+      else
+      {
+        thd->proc_info="Repair by sorting";
         error = mi_repair_by_sort(&param, file, fixed_name,
             param.testflag & T_QUICK);
       }
+    }
     else
     {
       thd->proc_info="Repair with keycache";

sql/item_func.cc

@@ -1110,47 +1110,6 @@ longlong Item_func_find_in_set::val_int()
   return 0;
 }
 
-static char nbits[256] = {
-  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
-};
-
-uint count_bits(ulonglong v)
-{
-#if SIZEOF_LONG_LONG > 4
-  /* The following code is a bit faster on 16 bit machines than if we would
-     only shift v */
-  ulong v2=(ulong) (v >> 32);
-  return (uint) (uchar) (nbits[(uchar)  v] +
-                         nbits[(uchar) (v >> 8)] +
-                         nbits[(uchar) (v >> 16)] +
-                         nbits[(uchar) (v >> 24)] +
-                         nbits[(uchar) (v2)] +
-                         nbits[(uchar) (v2 >> 8)] +
-                         nbits[(uchar) (v2 >> 16)] +
-                         nbits[(uchar) (v2 >> 24)]);
-#else
-  return (uint) (uchar) (nbits[(uchar)  v] +
-                         nbits[(uchar) (v >> 8)] +
-                         nbits[(uchar) (v >> 16)] +
-                         nbits[(uchar) (v >> 24)]);
-#endif
-}
-
 longlong Item_func_bit_count::val_int()
 {
   ulonglong value= (ulonglong) args[0]->val_int();
@@ -1159,7 +1118,7 @@ longlong Item_func_bit_count::val_int()
     null_value=1; /* purecov: inspected */
     return 0; /* purecov: inspected */
   }
-  return (longlong) count_bits(value);
+  return (longlong) my_count_bits(value);
 }
 
 
@@ -2221,7 +2180,7 @@ bool Item_func_match::fix_fields(THD *thd,struct st_table_list *tlist)
     used_tables_cache|=item->used_tables();
   }
   /* check that all columns come from the same table */
-  if (count_bits(used_tables_cache) != 1)
+  if (my_count_bits(used_tables_cache) != 1)
     key=NO_SUCH_KEY;
   const_item_cache=0;
   table=((Item_field *)fields.head())->field->table;

sql/mysqld.cc

@@ -3145,7 +3145,7 @@ enum options {
   OPT_SORT_BUFFER, OPT_TABLE_CACHE,
   OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
   OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
-  OPT_WAIT_TIMEOUT,
+  OPT_WAIT_TIMEOUT, OPT_MYISAM_REPAIR_THREADS,
   OPT_INNODB_MIRRORED_LOG_GROUPS,
   OPT_INNODB_LOG_FILES_IN_GROUP,
   OPT_INNODB_LOG_FILE_SIZE,
@@ -3844,6 +3844,11 @@ replicating a LOAD DATA INFILE command",
    (gptr*) &global_system_variables.myisam_max_sort_file_size,
    (gptr*) &max_system_variables.myisam_max_sort_file_size, 0,
    GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, ~0L, 0, 1024*1024, 0},
+  {"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,
+   "Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",
+   (gptr*) &global_system_variables.myisam_repair_threads,
+   (gptr*) &max_system_variables.myisam_repair_threads, 0,
+   GET_ULONG, REQUIRED_ARG, 1, 1, ~0L, 0, 1, 0},
   {"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,
    "The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
    (gptr*) &global_system_variables.myisam_sort_buff_size,

sql/set_var.cc

@@ -167,6 +167,7 @@ sys_var_long_ptr	sys_max_write_lock_count("max_write_lock_count",
 						 &max_write_lock_count);
 sys_var_thd_ulonglong	sys_myisam_max_extra_sort_file_size("myisam_max_extra_sort_file_size", &SV::myisam_max_extra_sort_file_size);
 sys_var_thd_ulonglong	sys_myisam_max_sort_file_size("myisam_max_sort_file_size", &SV::myisam_max_sort_file_size);
+sys_var_thd_ulong       sys_myisam_repair_threads("myisam_repair_threads", &SV::myisam_repair_threads);
 sys_var_thd_ulong	sys_myisam_sort_buffer_size("myisam_sort_buffer_size", &SV::myisam_sort_buff_size);
 sys_var_thd_ulong	sys_net_buffer_length("net_buffer_length",
 					      &SV::net_buffer_length);
@@ -347,6 +348,7 @@ sys_var *sys_variables[]=
   &sys_max_write_lock_count,
   &sys_myisam_max_extra_sort_file_size,
   &sys_myisam_max_sort_file_size,
+  &sys_myisam_repair_threads,
   &sys_myisam_sort_buffer_size,
   &sys_net_buffer_length,
   &sys_net_read_timeout,
@@ -489,8 +491,9 @@ struct show_var_st init_vars[]= {
   {sys_myisam_max_extra_sort_file_size.name,
    (char*) &sys_myisam_max_extra_sort_file_size,
    SHOW_SYS},
-  {sys_myisam_max_sort_file_size.name,
-   (char*) &sys_myisam_max_sort_file_size,
+  {sys_myisam_max_sort_file_size.name, (char*) &sys_myisam_max_sort_file_size,
+   SHOW_SYS},
+  {sys_myisam_repair_threads.name, (char*) &sys_myisam_repair_threads,
    SHOW_SYS},
   {"myisam_recover_options",  (char*) &myisam_recover_options_str,  SHOW_CHAR_PTR},
   {sys_myisam_sort_buffer_size.name, (char*) &sys_myisam_sort_buffer_size, SHOW_SYS},

sql/sql_class.h

@@ -294,6 +294,7 @@ struct system_variables
   ulong max_heap_table_size;
   ulong max_sort_length;
   ulong max_tmp_tables;
+  ulong myisam_repair_threads;
   ulong myisam_sort_buff_size;
   ulong net_buffer_length;
   ulong net_interactive_timeout;