Merge janus.mylan:/usr/home/serg/Abk/mysql-5.1

into  janus.mylan:/usr/home/serg/Abk/mysql-maria


Makefile.am:
  Auto merged
configure.in:
  Auto merged
BitKeeper/triggers/post-commit:
  Auto merged
client/mysqldump.c:
  Auto merged
client/mysqltest.c:
  Auto merged
include/my_dbug.h:
  Auto merged
include/mysql_com.h:
  Auto merged
libmysql/CMakeLists.txt:
  Auto merged
libmysqld/Makefile.am:
  Auto merged
mysql-test/lib/mtr_report.pl:
  Auto merged
mysql-test/mysql-test-run.pl:
  Auto merged
mysql-test/t/disabled.def:
  Auto merged
mysql-test/t/variables.test:
  Auto merged
server-tools/instance-manager/CMakeLists.txt:
  Auto merged
server-tools/instance-manager/mysql_connection.cc:
  Auto merged
sql/Makefile.am:
  Auto merged
sql/filesort.cc:
  Auto merged
sql/gen_lex_hash.cc:
  Auto merged
sql/ha_ndbcluster.cc:
  Auto merged
sql/ha_partition.cc:
  Auto merged
sql/item_func.cc:
  Auto merged
sql/item_strfunc.cc:
  Auto merged
sql/lex.h:
  Auto merged
sql/lock.cc:
  Auto merged
sql/log.cc:
  Auto merged
sql/net_serv.cc:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/set_var.h:
  Auto merged
sql/slave.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_delete.cc:
  Auto merged
sql/sql_insert.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.h:
  Auto merged
sql/sql_table.cc:
  Auto merged
sql/sql_update.cc:
  Auto merged
sql/sql_yacc.yy:
  Auto merged
sql/table.cc:
  Auto merged
sql/table.h:
  Auto merged
storage/myisam/ha_myisam.cc:
  Auto merged
storage/myisam/mi_open.c:
  Auto merged
storage/myisammrg/ha_myisammrg.cc:
  Auto merged
sql/handler.cc:
  merged
sql/handler.h:
  merged
sql/mysql_priv.h:
  merged
sql/mysqld.cc:
  merged
sql/set_var.cc:
  merged
sql/sql_select.cc:
  merged
sql/sql_show.cc:
  merged
unittest/mysys/my_atomic-t.c:
  merged

6 files changed, 250 insertions, 84 deletions

diff --git a/unittest/Makefile.am b/unittest/Makefile.am
index 65fa615fb98..8684fd3fc7d 100644
--- a/unittest/Makefile.am
+++ b/unittest/Makefile.am
@@ -13,7 +13,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-SUBDIRS      = mytap . mysys examples
+SUBDIRS      = mytap mysys examples
 
 EXTRA_DIST = unit.pl
 CLEANFILES = unit
diff --git a/unittest/mysys/Makefile.am b/unittest/mysys/Makefile.am
index be91ef31c9d..36ee285201e 100644
--- a/unittest/mysys/Makefile.am
+++ b/unittest/mysys/Makefile.am
@@ -13,15 +13,15 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-AM_CPPFLAGS      = @ZLIB_INCLUDES@ -I$(top_builddir)/include 
-AM_CPPFLAGS     += -I$(top_srcdir)/include -I$(top_srcdir)/unittest/mytap
+INCLUDES =		@ZLIB_INCLUDES@ -I$(top_builddir)/include \
+			-I$(top_srcdir)/include -I$(top_srcdir)/unittest/mytap 
+
+noinst_PROGRAMS  =    bitmap-t base64-t my_atomic-t
 
 LDADD 		= $(top_builddir)/unittest/mytap/libmytap.a \
 		  $(top_builddir)/mysys/libmysys.a \
 		  $(top_builddir)/dbug/libdbug.a \
 		  $(top_builddir)/strings/libmystrings.a
 
-noinst_PROGRAMS  = bitmap-t base64-t my_atomic-t
-
 # Don't update the files from bitkeeper
 %::SCCS/s.%
diff --git a/unittest/mysys/my_atomic-t.c b/unittest/mysys/my_atomic-t.c
index f2bcd360508..a24cbae272a 100644
--- a/unittest/mysys/my_atomic-t.c
+++ b/unittest/mysys/my_atomic-t.c
@@ -17,6 +17,7 @@
 #include <my_sys.h>
 #include <my_atomic.h>
 #include <tap.h>
+#include <lf.h>
 
 /* at least gcc 3.4.5 and 3.4.6 (but not 3.2.3) on RHEL */
 #if __GNUC__ == 3 && __GNUC_MINOR__ == 4
@@ -25,22 +26,24 @@
 #define GCC_BUG_WORKAROUND
 #endif
 
-int32 a32,b32,c32;
+volatile uint32 a32,b32;
+volatile int32  c32, N;
 my_atomic_rwlock_t rwl;
+LF_ALLOCATOR lf_allocator;
+LF_HASH lf_hash;
 
-pthread_attr_t thr_attr;
-pthread_mutex_t mutex;
-pthread_cond_t cond;
-int N;
+pthread_attr_t attr;
+size_t stacksize= 0;
+#define STACK_SIZE (((int)stacksize-2048)*STACK_DIRECTION)
 
 /* add and sub a random number in a loop. Must get 0 at the end */
 pthread_handler_t test_atomic_add_handler(void *arg)
 {
-  int    m=*(int *)arg;
+  int    m= (*(int *)arg)/2;
   GCC_BUG_WORKAROUND int32 x;
-  for (x=((int)((long)(&m))); m ; m--)
+  for (x= ((int)(intptr)(&m)); m ; m--)
   {
-    x=x*m+0x87654321;
+    x= (x*m+0x87654321) & INT_MAX32;
     my_atomic_rwlock_wrlock(&rwl);
     my_atomic_add32(&a32, x);
     my_atomic_rwlock_wrunlock(&rwl);
@@ -49,10 +52,6 @@ pthread_handler_t test_atomic_add_handler(void *arg)
     my_atomic_add32(&a32, -x);
     my_atomic_rwlock_wrunlock(&rwl);
   }
-  pthread_mutex_lock(&mutex);
-  N--;
-  if (!N) pthread_cond_signal(&cond);
-  pthread_mutex_unlock(&mutex);
   return 0;
 }
 
@@ -64,30 +63,24 @@ pthread_handler_t test_atomic_add_handler(void *arg)
   5. subtract result from a32
   must get 0 in a32 at the end
 */
-pthread_handler_t test_atomic_swap_handler(void *arg)
+pthread_handler_t test_atomic_fas_handler(void *arg)
 {
-  int    m=*(int *)arg;
-  int32 x;
+  int    m= *(int *)arg;
+  uint32  x= my_atomic_add32(&b32, 1);
 
-  my_atomic_rwlock_wrlock(&rwl);
-  x=my_atomic_add32(&b32, 1);
-  my_atomic_rwlock_wrunlock(&rwl);
-
-  my_atomic_rwlock_wrlock(&rwl);
   my_atomic_add32(&a32, x);
-  my_atomic_rwlock_wrunlock(&rwl);
 
   for (; m ; m--)
   {
     my_atomic_rwlock_wrlock(&rwl);
-    x=my_atomic_swap32(&c32, x);
+    x= my_atomic_fas32(&c32, x);
     my_atomic_rwlock_wrunlock(&rwl);
   }
 
   if (!x)
   {
     my_atomic_rwlock_wrlock(&rwl);
-    x=my_atomic_swap32(&c32, x);
+    x= my_atomic_fas32(&c32, x);
     my_atomic_rwlock_wrunlock(&rwl);
   }
 
@@ -95,111 +88,225 @@ pthread_handler_t test_atomic_swap_handler(void *arg)
   my_atomic_add32(&a32, -x);
   my_atomic_rwlock_wrunlock(&rwl);
 
-  pthread_mutex_lock(&mutex);
-  N--;
-  if (!N) pthread_cond_signal(&cond);
-  pthread_mutex_unlock(&mutex);
   return 0;
 }
 
 /*
   same as test_atomic_add_handler, but my_atomic_add32 is emulated with
-  (slower) my_atomic_cas32
+  my_atomic_cas32 - notice that the slowdown is proportional to the
+  number of CPUs
 */
 pthread_handler_t test_atomic_cas_handler(void *arg)
 {
-  int    m=*(int *)arg, ok;
-  GCC_BUG_WORKAROUND int32 x,y;
-  for (x=((int)((long)(&m))); m ; m--)
+  int    m= (*(int *)arg)/2, ok= 0;
+  GCC_BUG_WORKAROUND int32 x, y;
+  for (x= ((int)(intptr)(&m)); m ; m--)
   {
     my_atomic_rwlock_wrlock(&rwl);
-    y=my_atomic_load32(&a32);
+    y= my_atomic_load32(&a32);
     my_atomic_rwlock_wrunlock(&rwl);
-
-    x=x*m+0x87654321;
+    x= (x*m+0x87654321) & INT_MAX32;
     do {
       my_atomic_rwlock_wrlock(&rwl);
-      ok=my_atomic_cas32(&a32, &y, y+x);
+      ok= my_atomic_cas32(&a32, &y, (uint32)y+x);
       my_atomic_rwlock_wrunlock(&rwl);
-    } while (!ok);
+    } while (!ok) ;
     do {
       my_atomic_rwlock_wrlock(&rwl);
-      ok=my_atomic_cas32(&a32, &y, y-x);
+      ok= my_atomic_cas32(&a32, &y, y-x);
       my_atomic_rwlock_wrunlock(&rwl);
-    } while (!ok);
+    } while (!ok) ;
   }
-  pthread_mutex_lock(&mutex);
-  N--;
-  if (!N) pthread_cond_signal(&cond);
-  pthread_mutex_unlock(&mutex);
+  return 0;
+}
+
+/*
+  pin allocator - alloc and release an element in a loop
+*/
+pthread_handler_t test_lf_pinbox(void *arg)
+{
+  int    m= *(int *)arg;
+  int32 x= 0;
+  LF_PINS *pins;
+
+  pins= lf_pinbox_get_pins(&lf_allocator.pinbox, &m + STACK_SIZE);
+
+  for (x= ((int)(intptr)(&m)); m ; m--)
+  {
+    lf_pinbox_put_pins(pins);
+    pins= lf_pinbox_get_pins(&lf_allocator.pinbox, &m + STACK_SIZE);
+  }
+  lf_pinbox_put_pins(pins);
+  return 0;
+}
+
+typedef union {
+  int32 data;
+  void *not_used;
+} TLA;
+
+pthread_handler_t test_lf_alloc(void *arg)
+{
+  int    m= (*(int *)arg)/2;
+  int32 x,y= 0;
+  LF_PINS *pins;
+
+  pins= lf_alloc_get_pins(&lf_allocator, &m + STACK_SIZE);
+
+  for (x= ((int)(intptr)(&m)); m ; m--)
+  {
+    TLA *node1, *node2;
+    x= (x*m+0x87654321) & INT_MAX32;
+    node1= (TLA *)lf_alloc_new(pins);
+    node1->data= x;
+    y+= node1->data;
+    node1->data= 0;
+    node2= (TLA *)lf_alloc_new(pins);
+    node2->data= x;
+    y-= node2->data;
+    node2->data= 0;
+    lf_alloc_free(pins, node1);
+    lf_alloc_free(pins, node2);
+  }
+  lf_alloc_put_pins(pins);
+  my_atomic_rwlock_wrlock(&rwl);
+  my_atomic_add32(&a32, y);
+
+  if (my_atomic_add32(&N, -1) == 1)
+  {
+    diag("%d mallocs, %d pins in stack",
+         lf_allocator.mallocs, lf_allocator.pinbox.pins_in_array);
+#ifdef MY_LF_EXTRA_DEBUG
+    a32|= lf_allocator.mallocs - lf_alloc_pool_count(&lf_allocator);
+#endif
+  }
+  my_atomic_rwlock_wrunlock(&rwl);
+  return 0;
+}
+
+#define N_TLH 1000
+pthread_handler_t test_lf_hash(void *arg)
+{
+  int    m= (*(int *)arg)/(2*N_TLH);
+  int32 x,y,z,sum= 0, ins= 0;
+  LF_PINS *pins;
+
+  pins= lf_hash_get_pins(&lf_hash, &m + STACK_SIZE);
+
+  for (x= ((int)(intptr)(&m)); m ; m--)
+  {
+    int i;
+    y= x;
+    for (i= 0; i < N_TLH; i++)
+    {
+      x= (x*(m+i)+0x87654321) & INT_MAX32;
+      z= (x<0) ? -x : x;
+      if (lf_hash_insert(&lf_hash, pins, &z))
+      {
+        sum+= z;
+        ins++;
+      }
+    }
+    for (i= 0; i < N_TLH; i++)
+    {
+      y= (y*(m+i)+0x87654321) & INT_MAX32;
+      z= (y<0) ? -y : y;
+      if (lf_hash_delete(&lf_hash, pins, (uchar *)&z, sizeof(z)))
+        sum-= z;
+    }
+  }
+  lf_hash_put_pins(pins);
+  my_atomic_rwlock_wrlock(&rwl);
+  my_atomic_add32(&a32, sum);
+  my_atomic_add32(&b32, ins);
+
+  if (my_atomic_add32(&N, -1) == 1)
+  {
+    diag("%d mallocs, %d pins in stack, %d hash size, %d inserts",
+         lf_hash.alloc.mallocs, lf_hash.alloc.pinbox.pins_in_array,
+         lf_hash.size, b32);
+    a32|= lf_hash.count;
+  }
+  my_atomic_rwlock_wrunlock(&rwl);
   return 0;
 }
 
 void test_atomic(const char *test, pthread_handler handler, int n, int m)
 {
-  pthread_t t;
-  ulonglong now=my_getsystime();
+  pthread_t *threads;
+  ulonglong now= my_getsystime();
+  int i;
 
   a32= 0;
   b32= 0;
   c32= 0;
 
+  threads= (pthread_t *)my_malloc(sizeof(void *)*n, MYF(0));
+  if (!threads)
+  {
+    diag("Out of memory");
+    abort();
+  }
+
   diag("Testing %s with %d threads, %d iterations... ", test, n, m);
-  for (N=n ; n ; n--)
+  N= n;
+  for (i= 0 ; i < n ; i++)
   {
-    if (pthread_create(&t, &thr_attr, handler, &m) != 0)
+    if (pthread_create(threads+i, 0, handler, &m) != 0)
     {
       diag("Could not create thread");
-      a32= 1;
-      goto err;
+      abort();
     }
   }
-
-  pthread_mutex_lock(&mutex);
-  while (N)
-    pthread_cond_wait(&cond, &mutex);
-  pthread_mutex_unlock(&mutex);
-  now=my_getsystime()-now;
-err:
-  ok(a32 == 0, "tested %s in %g secs", test, ((double)now)/1e7);
+  for (i= 0 ; i < n ; i++)
+    pthread_join(threads[i], 0);
+  now= my_getsystime()-now;
+  ok(a32 == 0, "tested %s in %g secs (%d)", test, ((double)now)/1e7, a32);
+  my_free((void *)threads, MYF(0));
 }
 
+
 int main()
 {
   int err;
   MY_INIT("my_atomic-t.c");
 
-  diag("N CPUs: %d", my_getncpus());
+  diag("N CPUs: %d, atomic ops: %s", my_getncpus(), MY_ATOMIC_MODE);
   err= my_atomic_initialize();
 
-  plan(4);
+  plan(7);
   ok(err == 0, "my_atomic_initialize() returned %d", err);
 
-  pthread_attr_init(&thr_attr);
-  pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
-  pthread_mutex_init(&mutex, 0);
-  pthread_cond_init(&cond, 0);
   my_atomic_rwlock_init(&rwl);
+  lf_alloc_init(&lf_allocator, sizeof(TLA), offsetof(TLA, not_used));
+  lf_hash_init(&lf_hash, sizeof(int), LF_HASH_UNIQUE, 0, sizeof(int), 0,
+               &my_charset_bin);
 
-#ifdef HPUX11
-#define CYCLES 1000
+  pthread_attr_init(&attr);
+#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
+  pthread_attr_getstacksize(&attr, &stacksize);
+  if (stacksize == 0)
+#endif
+    stacksize= PTHREAD_STACK_MIN;
+
+#ifdef MY_ATOMIC_MODE_RWLOCKS
+#define CYCLES 3000
 #else
-#define CYCLES 10000
+#define CYCLES 300000
 #endif
 #define THREADS 100
-  test_atomic("my_atomic_add32", test_atomic_add_handler, THREADS, CYCLES);
-  test_atomic("my_atomic_swap32", test_atomic_swap_handler, THREADS, CYCLES);
-  test_atomic("my_atomic_cas32", test_atomic_cas_handler, THREADS, CYCLES);
-  /*
-    workaround until we know why it crashes randomly on some machine
-    (BUG#22320).
-  */
-  sleep(2);
-
-  pthread_mutex_destroy(&mutex);
-  pthread_cond_destroy(&cond);
-  pthread_attr_destroy(&thr_attr);
+
+  test_atomic("my_atomic_add32",  test_atomic_add_handler, THREADS,CYCLES);
+  test_atomic("my_atomic_fas32",  test_atomic_fas_handler, THREADS,CYCLES);
+  test_atomic("my_atomic_cas32",  test_atomic_cas_handler, THREADS,CYCLES);
+  test_atomic("lf_pinbox",        test_lf_pinbox,          THREADS,CYCLES);
+  test_atomic("lf_alloc",         test_lf_alloc,           THREADS,CYCLES);
+  test_atomic("lf_hash",          test_lf_hash,            THREADS,CYCLES/10);
+
+  lf_hash_destroy(&lf_hash);
+  lf_alloc_destroy(&lf_allocator);
   my_atomic_rwlock_destroy(&rwl);
+  my_end(0);
   return exit_status();
 }
 
diff --git a/unittest/mytap/tap.c b/unittest/mytap/tap.c
index 4e053e3e745..f9396adbd69 100644
--- a/unittest/mytap/tap.c
+++ b/unittest/mytap/tap.c
@@ -166,9 +166,17 @@ static signal_entry install_signal[]= {
 #endif
 };
 
+int skip_big_tests= 0;
+
 void
 plan(int const count)
 {
+  char *config= getenv("MYTAP_CONFIG");
+
+  if (config)
+    skip_big_tests= strcmp(config, "big");
+
+  setvbuf(tapout, 0, _IONBF, 0);  /* provide output at once */
   /*
     Install signal handler
   */
diff --git a/unittest/mytap/tap.h b/unittest/mytap/tap.h
index 31ec47d1ef2..f92fad1101f 100644
--- a/unittest/mytap/tap.h
+++ b/unittest/mytap/tap.h
@@ -62,6 +62,24 @@ extern "C" {
 #endif
 
 /**
+   Defines whether "big" tests should be skipped.
+
+   This variable is set by plan() function unless MYTAP_CONFIG environment
+   variable is set to the string "big".  It is supposed to be used as
+
+   @code
+   if (skip_big_tests) {
+     skip(1, "Big test skipped");
+   } else {
+     ok(life_universe_and_everything() == 42, "The answer is CORRECT");
+   }
+   @endcode
+
+   @see SKIP_BIG_TESTS
+*/
+extern int skip_big_tests;
+
+/**
   @defgroup MyTAP_API MyTAP API
 
   MySQL support for performing unit tests according to TAP.
@@ -81,7 +99,12 @@ extern "C" {
    that generate a core, so if you want to override these signals, do
    it <em>after</em> you have called the plan() function.
 
-   @param count The planned number of tests to run. 
+   It will also set skip_big_tests variable if MYTAP_CONFIG environment
+   variable is defined.
+
+   @see skip_big_tests
+
+   @param count The planned number of tests to run.
 */
 
 void plan(int count);
@@ -161,6 +184,24 @@ void skip(int how_many, char const *reason, ...)
 
 
 /**
+   Helper macro to skip a group of "big" tests. It is used in the following
+   manner:
+
+   @code
+   SKIP_BIG_TESTS(1)
+   {
+     ok(life_universe_and_everything() == 42, "The answer is CORRECT");
+   }
+   @endcode
+
+   @see skip_big_tests
+ */
+
+#define SKIP_BIG_TESTS(COUNT) \
+  if (skip_big_tests) skip((COUNT), "big test"); else
+
+
+/**
    Print a diagnostics message.
 
    @param fmt  Diagnostics message in printf() format.
diff --git a/unittest/unit.pl b/unittest/unit.pl
index 9d328985012..b83132581f9 100644
--- a/unittest/unit.pl
+++ b/unittest/unit.pl
@@ -14,8 +14,9 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-use Test::Harness qw(&runtests $verbose);
+use Test::Harness;
 use File::Find;
+use Getopt::Long;
 
 use strict;
 
@@ -35,6 +36,15 @@ unit - Run unit tests in directory
 
 =cut
 
+my $big=1;
+
+my $result = GetOptions (
+  "big!"        => \$big,
+  "verbose!"    => \$Test::Harness::verbose,
+);
+
+$ENV{'MYTAP_CONFIG'} = $big ? "big" : "";
+
 my $cmd = shift;
 
 if (defined $cmd && exists $dispatch{$cmd}) {