Merge bk-internal.mysql.com:/home/bk/mysql-maria

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


configure.in:
  Auto merged
include/my_global.h:
  Auto merged
include/my_sys.h:
  Auto merged
mysys/Makefile.am:
  Auto merged
sql/item_func.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/set_var.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_test.cc:
  Auto merged
storage/maria/Makefile.am:
  Auto merged
storage/maria/ha_maria.cc:
  Auto merged
storage/myisam/ha_myisam.cc:
  Auto merged
unittest/Makefile.am:
  Auto merged
unittest/mysys/my_atomic-t.c:
  merged

2 files changed, 165 insertions, 33 deletions

diff --git a/unittest/Makefile.am b/unittest/Makefile.am
index 7f1dd525d3b..c42398001c0 100644
--- a/unittest/Makefile.am
+++ b/unittest/Makefile.am
@@ -1,4 +1,4 @@
-SUBDIRS      = mytap . mysys examples
+SUBDIRS      = mytap mysys examples
 
 EXTRA_DIST = unit.pl
 CLEANFILES = unit
diff --git a/unittest/mysys/my_atomic-t.c b/unittest/mysys/my_atomic-t.c
index fe93b0942ce..881f80a66f8 100644
--- a/unittest/mysys/my_atomic-t.c
+++ b/unittest/mysys/my_atomic-t.c
@@ -14,13 +14,17 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-#include <my_global.h>
 #include <tap.h>
+
+#include <my_global.h>
 #include <my_sys.h>
 #include <my_atomic.h>
+#include <lf.h>
 
-int32 a32,b32,c32;
+volatile uint32 a32,b32,c32;
 my_atomic_rwlock_t rwl;
+LF_ALLOCATOR lf_allocator;
+LF_HASH lf_hash;
 
 pthread_attr_t thr_attr;
 pthread_mutex_t mutex;
@@ -30,11 +34,11 @@ int N;
 /* 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;
   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);
@@ -61,15 +65,9 @@ pthread_handler_t test_atomic_add_handler(void *arg)
 pthread_handler_t test_atomic_swap_handler(void *arg)
 {
   int    m=*(int *)arg;
-  int32 x;
-
-  my_atomic_rwlock_wrlock(&rwl);
-  x=my_atomic_add32(&b32, 1);
-  my_atomic_rwlock_wrunlock(&rwl);
+  uint32  x=my_atomic_add32(&b32, 1);
 
-  my_atomic_rwlock_wrlock(&rwl);
   my_atomic_add32(&a32, x);
-  my_atomic_rwlock_wrunlock(&rwl);
 
   for (; m ; m--)
   {
@@ -98,29 +96,29 @@ pthread_handler_t test_atomic_swap_handler(void *arg)
 
 /*
   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;
-  int32 x,y;
-  for (x=((int)((long)(&m))); m ; m--)
+  int    m=(*(int *)arg)/2, ok=0;
+  int32 x, y;
+  for (x=((int)(intptr)(&m)); m ; m--)
   {
     my_atomic_rwlock_wrlock(&rwl);
     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);
       my_atomic_rwlock_wrunlock(&rwl);
-    } while (!ok);
+    } while (!ok) ;
     do {
       my_atomic_rwlock_wrlock(&rwl);
       ok=my_atomic_cas32(&a32, &y, y-x);
       my_atomic_rwlock_wrunlock(&rwl);
-    } while (!ok);
+    } while (!ok) ;
   }
   pthread_mutex_lock(&mutex);
   N--;
@@ -129,6 +127,128 @@ pthread_handler_t test_atomic_cas_handler(void *arg)
   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);
+
+  for (x=((int)(intptr)(&m)); m ; m--)
+  {
+    lf_pinbox_put_pins(pins);
+    pins=lf_pinbox_get_pins(&lf_allocator.pinbox);
+  }
+  lf_pinbox_put_pins(pins);
+  pthread_mutex_lock(&mutex);
+  N--;
+  if (!N)
+    pthread_cond_signal(&cond);
+  pthread_mutex_unlock(&mutex);
+  return 0;
+}
+
+typedef union {
+  int32 data;
+  void *not_used; /* to guarantee sizeof(TLA) >= sizeof(void *) */
+} 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);
+
+  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);
+  my_atomic_rwlock_wrunlock(&rwl);
+  pthread_mutex_lock(&mutex);
+  N--;
+  if (!N)
+  {
+    diag("%d mallocs, %d pins in stack",
+         lf_allocator.mallocs, lf_allocator.pinbox.pins_in_stack);
+#ifdef MY_LF_EXTRA_DEBUG
+    a32|=lf_allocator.mallocs - lf_alloc_in_pool(&lf_allocator);
+#endif
+    pthread_cond_signal(&cond);
+  }
+  pthread_mutex_unlock(&mutex);
+  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);
+
+  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);
+  my_atomic_rwlock_wrunlock(&rwl);
+  pthread_mutex_lock(&mutex);
+  N--;
+  if (!N)
+  {
+    diag("%d mallocs, %d pins in stack, %d hash size, %d inserts",
+         lf_hash.alloc.mallocs, lf_hash.alloc.pinbox.pins_in_stack,
+         lf_hash.size, b32);
+    a32|=lf_hash.count;
+    pthread_cond_signal(&cond);
+  }
+  pthread_mutex_unlock(&mutex);
+  return 0;
+}
+
 void test_atomic(const char *test, pthread_handler handler, int n, int m)
 {
   pthread_t t;
@@ -148,24 +268,25 @@ void test_atomic(const char *test, pthread_handler handler, int n, int m)
       goto err;
     }
   }
-
   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);
+  ok(a32 == 0, "tested %s in %g secs (%d)", test, ((double)now)/1e7, a32);
 }
 
 int main()
 {
   int err;
 
-  diag("N CPUs: %d", my_getncpus());
+  my_init();
+
+  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);
@@ -173,21 +294,32 @@ int main()
   pthread_mutex_init(&mutex, 0);
   pthread_cond_init(&cond, 0);
   my_atomic_rwlock_init(&rwl);
+  lf_alloc_init(&lf_allocator, sizeof(TLA));
+  lf_hash_init(&lf_hash, sizeof(int), LF_HASH_UNIQUE, 0, sizeof(int), 0,
+               &my_charset_bin);
+
+#ifdef MY_ATOMIC_MODE_RWLOCKS
+#define CYCLES 10000
+#else
+#define CYCLES 1000000
+#endif
+#define THREADS 100
 
-  test_atomic("my_atomic_add32", test_atomic_add_handler, 100,10000);
-  test_atomic("my_atomic_swap32", test_atomic_swap_handler, 100,10000);
-  test_atomic("my_atomic_cas32", test_atomic_cas_handler, 100,10000);
+  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);
+  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);
 
-  /*
-    workaround until we know why it crashes randomly on some machine
-    (BUG#22320).
-  */
-  sleep(2);
+  lf_hash_destroy(&lf_hash);
+  lf_alloc_destroy(&lf_allocator);
 
   pthread_mutex_destroy(&mutex);
   pthread_cond_destroy(&cond);
   pthread_attr_destroy(&thr_attr);
   my_atomic_rwlock_destroy(&rwl);
+  my_end(0);
   return exit_status();
 }