Merge gbichot3.local:/home/mysql_src/mysql-5.1-clean

into  gbichot3.local:/home/mysql_src/mysql-maria


BitKeeper/etc/ignore:
  auto-union
BUILD/SETUP.sh:
  Auto merged
Makefile.am:
  Auto merged
config/ac-macros/plugins.m4:
  Auto merged
configure.in:
  Auto merged
include/Makefile.am:
  Auto merged
include/my_base.h:
  Auto merged
include/my_dbug.h:
  Auto merged
include/my_global.h:
  Auto merged
include/my_sys.h:
  Auto merged
libmysqld/Makefile.am:
  Auto merged
mysql-test/mysql-test-run.pl:
  Auto merged
mysys/Makefile.am:
  Auto merged
mysys/my_pread.c:
  Auto merged
sql/Makefile.am:
  Auto merged
sql/handler.h:
  Auto merged
sql/item_func.cc:
  Auto merged
sql/item_func.h:
  Auto merged
sql/log.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/set_var.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/unireg.cc:
  Auto merged
storage/csv/ha_tina.cc:
  Auto merged
storage/myisam/ha_myisam.cc:
  Auto merged
storage/myisam/ha_myisam.h:
  Auto merged
storage/myisam/mi_open.c:
  Auto merged
storage/myisam/mi_packrec.c:
  Auto merged
storage/myisam/mi_range.c:
  Auto merged
storage/myisam/myisampack.c:
  Auto merged
storage/myisam/sort.c:
  Auto merged
storage/myisammrg/ha_myisammrg.h:
  Auto merged
unittest/mytap/tap.c:
  Auto merged
include/myisam.h:
  merge
sql/mysqld.cc:
  merge
storage/myisam/mi_check.c:
  merge
storage/myisam/myisamdef.h:
  merge

8 files changed, 1346 insertions, 78 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/Makefile.am b/unittest/mysys/Makefile.am
index 8e6255b9e68..f7b72255a72 100644
--- a/unittest/mysys/Makefile.am
+++ b/unittest/mysys/Makefile.am
@@ -1,11 +1,58 @@
+INCLUDES =		@ZLIB_INCLUDES@ -I$(top_builddir)/include \
+			-I$(top_srcdir)/include -I$(top_srcdir)/unittest/mytap 
 
-AM_CPPFLAGS      = @ZLIB_INCLUDES@ -I$(top_builddir)/include 
-AM_CPPFLAGS     += -I$(top_srcdir)/include -I$(top_srcdir)/unittest/mytap
 
 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
+# tests with the "big" suffix are too big to run for every push,
+# cause load problems on shared machines. So we build them,
+# but don't run them by default (for this, a non "-t" suffix is used).
+# You can run them by hand (how: see "test" target in upper dir).
+noinst_PROGRAMS  =	bitmap-t base64-t my_atomic-t \
+			mf_pagecache_single_1k-t mf_pagecache_single_8k-t \
+			mf_pagecache_single_64k-t-big \
+			mf_pagecache_consist_1k-t-big mf_pagecache_consist_64k-t-big \
+			mf_pagecache_consist_1kHC-t-big mf_pagecache_consist_64kHC-t-big \
+			mf_pagecache_consist_1kRD-t-big mf_pagecache_consist_64kRD-t-big \
+			mf_pagecache_consist_1kWR-t-big mf_pagecache_consist_64kWR-t-big
 
+# tests for mysys/mf_pagecache.c
+
+mf_pagecache_single_src =	mf_pagecache_single.c $(top_srcdir)/mysys/mf_pagecache.c test_file.c test_file.h
+mf_pagecache_consist_src =	mf_pagecache_consist.c $(top_srcdir)/mysys/mf_pagecache.c test_file.c test_file.h
+mf_pagecache_common_cppflags =	-DEXTRA_DEBUG -DPAGECACHE_DEBUG -DMAIN
+
+# Those two take reasonable resources (<100 MB) for < 1 minute
+mf_pagecache_single_1k_t_SOURCES =	$(mf_pagecache_single_src)
+mf_pagecache_single_8k_t_SOURCES =	$(mf_pagecache_single_src)
+mf_pagecache_single_1k_t_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024
+mf_pagecache_single_8k_t_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=8192
+
+# All others below are big
+mf_pagecache_single_64k_t_big_SOURCES =	$(mf_pagecache_single_src)
+mf_pagecache_single_64k_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536
+
+mf_pagecache_consist_1k_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_1k_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024
+mf_pagecache_consist_64k_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_64k_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536
+
+mf_pagecache_consist_1kHC_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_1kHC_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024 -DTEST_HIGH_CONCURENCY
+mf_pagecache_consist_64kHC_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_64kHC_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536 -DTEST_HIGH_CONCURENCY
+
+mf_pagecache_consist_1kRD_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_1kRD_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024 -DTEST_READERS
+mf_pagecache_consist_64kRD_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_64kRD_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536 -DTEST_READERS
+
+mf_pagecache_consist_1kWR_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_1kWR_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024 -DTEST_WRITERS
+mf_pagecache_consist_64kWR_t_big_SOURCES =	$(mf_pagecache_consist_src)
+mf_pagecache_consist_64kWR_t_big_CPPFLAGS = 	$(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536 -DTEST_WRITERS
+
+CLEANFILES = 	pagecache_debug.log page_cache_test_file_1
diff --git a/unittest/mysys/mf_pagecache_consist.c b/unittest/mysys/mf_pagecache_consist.c
new file mode 100755
index 00000000000..f7724222a09
--- /dev/null
+++ b/unittest/mysys/mf_pagecache_consist.c
@@ -0,0 +1,445 @@
+/*
+  TODO: use pthread_join instead of wait_for_thread_count_to_be_zero, like in
+  my_atomic-t.c (see BUG#22320).
+  Use diag() instead of fprintf(stderr). Use ok() and plan().
+*/
+
+#include <tap.h>
+#include <my_sys.h>
+#include <m_string.h>
+#include "test_file.h"
+
+#define PCACHE_SIZE (PAGE_SIZE*1024*8)
+
+#ifndef DBUG_OFF
+static const char* default_dbug_option;
+#endif
+
+static char *file1_name= (char*)"page_cache_test_file_1";
+static PAGECACHE_FILE file1;
+static pthread_cond_t COND_thread_count;
+static pthread_mutex_t LOCK_thread_count;
+static uint thread_count;
+static PAGECACHE pagecache;
+
+#ifdef TEST_HIGH_CONCURENCY
+static uint number_of_readers= 10;
+static uint number_of_writers= 20;
+static uint number_of_tests= 30000;
+static uint record_length_limit= PAGE_SIZE/200;
+static uint number_of_pages= 20;
+static uint flush_divider= 1000;
+#else /*TEST_HIGH_CONCURENCY*/
+#ifdef TEST_READERS
+static uint number_of_readers= 10;
+static uint number_of_writers= 1;
+static uint number_of_tests= 30000;
+static uint record_length_limit= PAGE_SIZE/200;
+static uint number_of_pages= 20;
+static uint flush_divider= 1000;
+#else /*TEST_READERS*/
+#ifdef TEST_WRITERS
+static uint number_of_readers= 0;
+static uint number_of_writers= 10;
+static uint number_of_tests= 30000;
+static uint record_length_limit= PAGE_SIZE/200;
+static uint number_of_pages= 20;
+static uint flush_divider= 1000;
+#else /*TEST_WRITERS*/
+static uint number_of_readers= 10;
+static uint number_of_writers= 10;
+static uint number_of_tests= 50000;
+static uint record_length_limit= PAGE_SIZE/200;
+static uint number_of_pages= 20000;
+static uint flush_divider= 1000;
+#endif /*TEST_WRITERS*/
+#endif /*TEST_READERS*/
+#endif /*TEST_HIGH_CONCURENCY*/
+
+
+/* check page consistency */
+uint check_page(uchar *buff, ulong offset, int page_locked, int page_no,
+                int tag)
+{
+  uint end= sizeof(uint);
+  uint num= *((uint *)buff);
+  uint i;
+  DBUG_ENTER("check_page");
+
+  for (i= 0; i < num; i++)
+  {
+    uint len= *((uint *)(buff + end));
+    uint j;
+    end+= sizeof(uint)+ sizeof(uint);
+    if (len + end > PAGE_SIZE)
+    {
+      diag("incorrect field header #%u by offset %lu\n", i, offset + end + j);
+      goto err;
+    }
+    for(j= 0; j < len; j++)
+    {
+      if (buff[end + j] != (uchar)((i+1) % 256))
+      {
+        diag("incorrect %lu byte\n", offset + end + j);
+        goto err;
+      }
+    }
+    end+= len;
+  }
+  for(i= end; i < PAGE_SIZE; i++)
+  {
+    if (buff[i] != 0)
+    {
+      int h;
+      DBUG_PRINT("err",
+                 ("byte %lu (%lu + %u), page %u (%s, end: %u, recs: %u, tag: %d) should be 0\n",
+                  offset + i, offset, i, page_no,
+                  (page_locked ? "locked" : "unlocked"),
+                  end, num, tag));
+      diag("byte %lu (%lu + %u), page %u (%s, end: %u, recs: %u, tag: %d) should be 0\n",
+           offset + i, offset, i, page_no,
+           (page_locked ? "locked" : "unlocked"),
+           end, num, tag);
+      h= my_open("wrong_page", O_CREAT | O_TRUNC | O_RDWR, MYF(0));
+      my_pwrite(h, buff, PAGE_SIZE, 0, MYF(0));
+      my_close(h, MYF(0));
+      goto err;
+    }
+  }
+  DBUG_RETURN(end);
+err:
+  DBUG_PRINT("err", ("try to flush"));
+  if (page_locked)
+  {
+    pagecache_delete_page(&pagecache, &file1, page_no,
+                          PAGECACHE_LOCK_LEFT_WRITELOCKED, 1);
+  }
+  else
+  {
+    flush_pagecache_blocks(&pagecache, &file1, FLUSH_RELEASE);
+  }
+  exit(1);
+}
+
+void put_rec(uchar *buff, uint end, uint len, uint tag)
+{
+  uint i;
+  uint num= *((uint *)buff);
+  if (!len)
+    len= 1;
+  if (end + sizeof(uint)*2 + len > PAGE_SIZE)
+    return;
+  *((uint *)(buff + end))= len;
+  end+=  sizeof(uint);
+  *((uint *)(buff + end))= tag;
+  end+=  sizeof(uint);
+  num++;
+  *((uint *)buff)= num;
+  *((uint*)(buff + end))= len;
+  for (i= end; i < (len + end); i++)
+  {
+    buff[i]= (uchar) num % 256;
+  }
+}
+
+/*
+  Recreate and reopen a file for test
+
+  SYNOPSIS
+    reset_file()
+    file                 File to reset
+    file_name            Path (and name) of file which should be reset
+*/
+
+void reset_file(PAGECACHE_FILE file, char *file_name)
+{
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_RELEASE);
+  if (my_close(file1.file, MYF(0)) != 0)
+  {
+    diag("Got error during %s closing from close() (errno: %d)\n",
+         file_name, errno);
+    exit(1);
+  }
+  my_delete(file_name, MYF(0));
+  if ((file.file= my_open(file_name,
+                          O_CREAT | O_TRUNC | O_RDWR, MYF(0))) == -1)
+  {
+    diag("Got error during %s creation from open() (errno: %d)\n",
+         file_name, errno);
+    exit(1);
+  }
+}
+
+
+void reader(int num)
+{
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  uint i;
+
+  for (i= 0; i < number_of_tests; i++)
+  {
+    uint page= rand()/(RAND_MAX/number_of_pages);
+    pagecache_read(&pagecache, &file1, page, 3, (char*)buffr,
+                   PAGECACHE_PLAIN_PAGE,
+                   PAGECACHE_LOCK_LEFT_UNLOCKED,
+                   0);
+    check_page(buffr, page * PAGE_SIZE, 0, page, -num);
+    if (i % 500 == 0)
+      printf("reader%d: %d\n", num, i);
+
+  }
+  printf("reader%d: done\n", num);
+  free(buffr);
+}
+
+
+void writer(int num)
+{
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  uint i;
+
+  for (i= 0; i < number_of_tests; i++)
+  {
+    uint end;
+    uint page= rand()/(RAND_MAX/number_of_pages);
+    pagecache_read(&pagecache, &file1, page, 3, (char*)buffr,
+                   PAGECACHE_PLAIN_PAGE,
+                   PAGECACHE_LOCK_WRITE,
+                   0);
+    end= check_page(buffr, page * PAGE_SIZE, 1, page, num);
+    put_rec(buffr, end, rand()/(RAND_MAX/record_length_limit), num);
+    pagecache_write(&pagecache, &file1, page, 3, (char*)buffr,
+                    PAGECACHE_PLAIN_PAGE,
+                    PAGECACHE_LOCK_WRITE_UNLOCK,
+                    PAGECACHE_UNPIN,
+                    PAGECACHE_WRITE_DELAY,
+                    0);
+
+    if (i % flush_divider == 0)
+      flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+    if (i % 500 == 0)
+      printf("writer%d: %d\n", num, i);
+  }
+  printf("writer%d: done\n", num);
+  free(buffr);
+}
+
+
+static void *test_thread_reader(void *arg)
+{
+  int param=*((int*) arg);
+
+  my_thread_init();
+  DBUG_ENTER("test_reader");
+  DBUG_PRINT("enter", ("param: %d", param));
+
+  reader(param);
+
+  DBUG_PRINT("info", ("Thread %s ended\n", my_thread_name()));
+  pthread_mutex_lock(&LOCK_thread_count);
+  thread_count--;
+  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_mutex_unlock(&LOCK_thread_count);
+  free((gptr) arg);
+  my_thread_end();
+  DBUG_RETURN(0);
+}
+
+static void *test_thread_writer(void *arg)
+{
+  int param=*((int*) arg);
+
+  my_thread_init();
+  DBUG_ENTER("test_writer");
+  DBUG_PRINT("enter", ("param: %d", param));
+
+  writer(param);
+
+  DBUG_PRINT("info", ("Thread %s ended\n", my_thread_name()));
+  pthread_mutex_lock(&LOCK_thread_count);
+  thread_count--;
+  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_mutex_unlock(&LOCK_thread_count);
+  free((gptr) arg);
+  my_thread_end();
+  DBUG_RETURN(0);
+}
+
+int main(int argc, char **argv __attribute__((unused)))
+{
+  pthread_t tid;
+  pthread_attr_t thr_attr;
+  int *param, error, pagen;
+
+  MY_INIT(argv[0]);
+
+#ifndef DBUG_OFF
+#if defined(__WIN__)
+  default_dbug_option= "d:t:i:O,\\test_pagecache_consist.trace";
+#else
+  default_dbug_option= "d:t:i:o,/tmp/test_pagecache_consist.trace";
+#endif
+  if (argc > 1)
+  {
+    DBUG_SET(default_dbug_option);
+    DBUG_SET_INITIAL(default_dbug_option);
+  }
+#endif
+
+
+  DBUG_ENTER("main");
+  DBUG_PRINT("info", ("Main thread: %s\n", my_thread_name()));
+  if ((file1.file= my_open(file1_name,
+                           O_CREAT | O_TRUNC | O_RDWR, MYF(0))) == -1)
+  {
+    fprintf(stderr, "Got error during file1 creation from open() (errno: %d)\n",
+	    errno);
+    exit(1);
+  }
+  DBUG_PRINT("info", ("file1: %d", file1.file));
+  if (chmod(file1_name, S_IRWXU | S_IRWXG | S_IRWXO) != 0)
+  {
+    fprintf(stderr, "Got error during file1 chmod() (errno: %d)\n",
+	    errno);
+    exit(1);
+  }
+  my_pwrite(file1.file, "test file", 9, 0, MYF(0));
+
+  if ((error= pthread_cond_init(&COND_thread_count, NULL)))
+  {
+    fprintf(stderr, "COND_thread_count: %d from pthread_cond_init (errno: %d)\n",
+	    error, errno);
+    exit(1);
+  }
+  if ((error= pthread_mutex_init(&LOCK_thread_count, MY_MUTEX_INIT_FAST)))
+  {
+    fprintf(stderr, "LOCK_thread_count: %d from pthread_cond_init (errno: %d)\n",
+	    error, errno);
+    exit(1);
+  }
+
+  if ((error= pthread_attr_init(&thr_attr)))
+  {
+    fprintf(stderr,"Got error: %d from pthread_attr_init (errno: %d)\n",
+	    error,errno);
+    exit(1);
+  }
+  if ((error= pthread_attr_setdetachstate(&thr_attr, PTHREAD_CREATE_DETACHED)))
+  {
+    fprintf(stderr,
+	    "Got error: %d from pthread_attr_setdetachstate (errno: %d)\n",
+	    error,errno);
+    exit(1);
+  }
+
+#ifndef pthread_attr_setstacksize		/* void return value */
+  if ((error= pthread_attr_setstacksize(&thr_attr, 65536L)))
+  {
+    fprintf(stderr,"Got error: %d from pthread_attr_setstacksize (errno: %d)\n",
+	    error,errno);
+    exit(1);
+  }
+#endif
+#ifdef HAVE_THR_SETCONCURRENCY
+  VOID(thr_setconcurrency(2));
+#endif
+
+  my_thread_global_init();
+
+
+  if ((pagen= init_pagecache(&pagecache, PCACHE_SIZE, 0, 0,
+                             PAGE_SIZE, 0)) == 0)
+  {
+    fprintf(stderr,"Got error: init_pagecache() (errno: %d)\n",
+            errno);
+    exit(1);
+  }
+  DBUG_PRINT("info", ("Page cache %d pages", pagen));
+  {
+    unsigned char *buffr= malloc(PAGE_SIZE);
+    uint i;
+    memset(buffr, '\0', PAGE_SIZE);
+    for (i= 0; i < number_of_pages; i++)
+    {
+      pagecache_write(&pagecache, &file1, i, 3, (char*)buffr,
+                      PAGECACHE_PLAIN_PAGE,
+                      PAGECACHE_LOCK_LEFT_UNLOCKED,
+                      PAGECACHE_PIN_LEFT_UNPINNED,
+                      PAGECACHE_WRITE_DELAY,
+                      0);
+    }
+    flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+    free(buffr);
+  }
+  if ((error= pthread_mutex_lock(&LOCK_thread_count)))
+  {
+    fprintf(stderr,"LOCK_thread_count: %d from pthread_mutex_lock (errno: %d)\n",
+            error,errno);
+    exit(1);
+  }
+  while (number_of_readers != 0 || number_of_writers != 0)
+  {
+    if (number_of_readers != 0)
+    {
+      param=(int*) malloc(sizeof(int));
+      *param= number_of_readers;
+      if ((error= pthread_create(&tid, &thr_attr, test_thread_reader,
+                                 (void*) param)))
+      {
+        fprintf(stderr,"Got error: %d from pthread_create (errno: %d)\n",
+                error,errno);
+        exit(1);
+      }
+      thread_count++;
+      number_of_readers--;
+    }
+    if (number_of_writers != 0)
+    {
+      param=(int*) malloc(sizeof(int));
+      *param= number_of_writers;
+      if ((error= pthread_create(&tid, &thr_attr, test_thread_writer,
+                                 (void*) param)))
+      {
+        fprintf(stderr,"Got error: %d from pthread_create (errno: %d)\n",
+                error,errno);
+        exit(1);
+      }
+      thread_count++;
+      number_of_writers--;
+    }
+  }
+  DBUG_PRINT("info", ("Thread started"));
+  pthread_mutex_unlock(&LOCK_thread_count);
+
+  pthread_attr_destroy(&thr_attr);
+
+  /* wait finishing */
+  if ((error= pthread_mutex_lock(&LOCK_thread_count)))
+    fprintf(stderr,"LOCK_thread_count: %d from pthread_mutex_lock\n",error);
+  while (thread_count)
+  {
+    if ((error= pthread_cond_wait(&COND_thread_count,&LOCK_thread_count)))
+      fprintf(stderr,"COND_thread_count: %d from pthread_cond_wait\n",error);
+  }
+  if ((error= pthread_mutex_unlock(&LOCK_thread_count)))
+    fprintf(stderr,"LOCK_thread_count: %d from pthread_mutex_unlock\n",error);
+  DBUG_PRINT("info", ("thread ended"));
+
+  end_pagecache(&pagecache, 1);
+  DBUG_PRINT("info", ("Page cache ended"));
+
+  if (my_close(file1.file, MYF(0)) != 0)
+  {
+    fprintf(stderr, "Got error during file1 closing from close() (errno: %d)\n",
+	    errno);
+    exit(1);
+  }
+  /*my_delete(file1_name, MYF(0));*/
+  my_thread_global_end();
+
+  DBUG_PRINT("info", ("file1 (%d) closed", file1.file));
+
+  DBUG_PRINT("info", ("Program end"));
+
+  DBUG_RETURN(exit_status());
+}
diff --git a/unittest/mysys/mf_pagecache_single.c b/unittest/mysys/mf_pagecache_single.c
new file mode 100644
index 00000000000..49ecd2986ab
--- /dev/null
+++ b/unittest/mysys/mf_pagecache_single.c
@@ -0,0 +1,587 @@
+/*
+  TODO: use pthread_join instead of wait_for_thread_count_to_be_zero, like in
+  my_atomic-t.c (see BUG#22320).
+  Use diag() instead of fprintf(stderr).
+*/
+#include <tap.h>
+#include <my_sys.h>
+#include <m_string.h>
+#include "test_file.h"
+
+#define PCACHE_SIZE (PAGE_SIZE*1024*10)
+
+#ifndef DBUG_OFF
+static const char* default_dbug_option;
+#endif
+
+static char *file1_name= (char*)"page_cache_test_file_1";
+static PAGECACHE_FILE file1;
+static pthread_cond_t COND_thread_count;
+static pthread_mutex_t LOCK_thread_count;
+static uint thread_count;
+static PAGECACHE pagecache;
+
+/*
+  File contance descriptors
+*/
+static struct file_desc simple_read_write_test_file[]=
+{
+  {PAGE_SIZE, '\1'},
+  { 0, 0}
+};
+static struct file_desc simple_read_change_write_read_test_file[]=
+{
+  {PAGE_SIZE/2, '\65'},
+  {PAGE_SIZE/2, '\1'},
+  { 0, 0}
+};
+static struct file_desc simple_pin_test_file1[]=
+{
+  {PAGE_SIZE*2, '\1'},
+  { 0, 0}
+};
+static struct file_desc simple_pin_test_file2[]=
+{
+  {PAGE_SIZE/2, '\1'},
+  {PAGE_SIZE/2, (unsigned char)129},
+  {PAGE_SIZE, '\1'},
+  { 0, 0}
+};
+static struct file_desc  simple_delete_forget_test_file[]=
+{
+  {PAGE_SIZE, '\1'},
+  { 0, 0}
+};
+static struct file_desc  simple_delete_flush_test_file[]=
+{
+  {PAGE_SIZE, '\2'},
+  { 0, 0}
+};
+
+
+/*
+  Recreate and reopen a file for test
+
+  SYNOPSIS
+    reset_file()
+    file                 File to reset
+    file_name            Path (and name) of file which should be reset
+*/
+
+void reset_file(PAGECACHE_FILE file, char *file_name)
+{
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_RELEASE);
+  if (my_close(file1.file, MYF(0)) != 0)
+  {
+    diag("Got error during %s closing from close() (errno: %d)\n",
+         file_name, errno);
+    exit(1);
+  }
+  my_delete(file_name, MYF(0));
+  if ((file.file= my_open(file_name,
+                          O_CREAT | O_TRUNC | O_RDWR, MYF(0))) == -1)
+  {
+    diag("Got error during %s creation from open() (errno: %d)\n",
+         file_name, errno);
+    exit(1);
+  }
+}
+
+/*
+  Write then read page, check file on disk
+*/
+
+int simple_read_write_test()
+{
+  unsigned char *buffw= malloc(PAGE_SIZE);
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  int res;
+  DBUG_ENTER("simple_read_write_test");
+  bfill(buffw, PAGE_SIZE, '\1');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_UNLOCKED,
+                  PAGECACHE_PIN_LEFT_UNPINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffr,
+                 PAGECACHE_PLAIN_PAGE,
+                 PAGECACHE_LOCK_LEFT_UNLOCKED,
+                 0);
+  ok((res= test(memcmp(buffr, buffw, PAGE_SIZE) == 0)),
+     "Simple write-read page ");
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  ok((res&= test(test_file(file1, file1_name, PAGE_SIZE, PAGE_SIZE,
+                           simple_read_write_test_file))),
+     "Simple write-read page file");
+  if (res)
+    reset_file(file1, file1_name);
+  free(buffw);
+  free(buffr);
+  DBUG_RETURN(res);
+}
+
+
+/*
+  Prepare page, then read (and lock), change (write new value and unlock),
+  then check the page in the cache and on the disk
+*/
+int simple_read_change_write_read_test()
+{
+  unsigned char *buffw= malloc(PAGE_SIZE);
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  int res;
+  DBUG_ENTER("simple_read_change_write_read_test");
+  /* prepare the file */
+  bfill(buffw, PAGE_SIZE, '\1');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_UNLOCKED,
+                  PAGECACHE_PIN_LEFT_UNPINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  /* test */
+  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffw,
+                 PAGECACHE_PLAIN_PAGE,
+                 PAGECACHE_LOCK_WRITE,
+                 0);
+  bfill(buffw, PAGE_SIZE/2, '\65');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_WRITE_UNLOCK,
+                  PAGECACHE_UNPIN,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+
+  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffr,
+                 PAGECACHE_PLAIN_PAGE,
+                 PAGECACHE_LOCK_LEFT_UNLOCKED,
+                 0);
+  ok((res= test(memcmp(buffr, buffw, PAGE_SIZE) == 0)),
+     "Simple read-change-write-read page ");
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  ok((res&= test(test_file(file1, file1_name, PAGE_SIZE, PAGE_SIZE,
+                           simple_read_change_write_read_test_file))),
+     "Simple read-change-write-read page file");
+  if (res)
+    reset_file(file1, file1_name);
+  free(buffw);
+  free(buffr);
+  DBUG_RETURN(res);
+}
+
+
+/*
+  Prepare page, read page 0 (and pin) then write page 1 and page 0.
+  Flush the file (shold flush only page 1 and return 1 (page 0 is
+  still pinned).
+  Check file on the disk.
+  Unpin and flush.
+  Check file on the disk.
+*/
+int simple_pin_test()
+{
+  unsigned char *buffw= malloc(PAGE_SIZE);
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  int res;
+  DBUG_ENTER("simple_pin_test");
+  /* prepare the file */
+  bfill(buffw, PAGE_SIZE, '\1');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_UNLOCKED,
+                  PAGECACHE_PIN_LEFT_UNPINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  /* test */
+  if (flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE))
+  {
+    diag("error in flush_pagecache_blocks\n");
+    exit(1);
+  }
+  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffw,
+                 PAGECACHE_PLAIN_PAGE,
+                 PAGECACHE_LOCK_WRITE,
+                 0);
+  pagecache_write(&pagecache, &file1, 1, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_UNLOCKED,
+                  PAGECACHE_PIN_LEFT_UNPINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  bfill(buffw + PAGE_SIZE/2, PAGE_SIZE/2, ((unsigned char) 129));
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_WRITE_TO_READ,
+                  PAGECACHE_PIN_LEFT_PINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  /*
+    We have to get error because one page of the file is pinned,
+    other page should be flushed
+  */
+  if (!flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE))
+  {
+    diag("Did not get error in flush_pagecache_blocks\n");
+    res= 0;
+    goto err;
+  }
+  ok((res= test(test_file(file1, file1_name, PAGE_SIZE*2, PAGE_SIZE*2,
+                           simple_pin_test_file1))),
+     "Simple pin page file with pin");
+  pagecache_unlock_page(&pagecache,
+                        &file1,
+                        0,
+                        PAGECACHE_LOCK_READ_UNLOCK,
+                        PAGECACHE_UNPIN,
+                        0, 0);
+  if (flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE))
+  {
+    diag("Got error in flush_pagecache_blocks\n");
+    res= 0;
+    goto err;
+  }
+  ok((res&= test(test_file(file1, file1_name, PAGE_SIZE*2, PAGE_SIZE,
+                           simple_pin_test_file2))),
+     "Simple pin page result file");
+  if (res)
+    reset_file(file1, file1_name);
+err:
+  free(buffw);
+  free(buffr);
+  DBUG_RETURN(res);
+}
+
+/*
+  Prepare page, write new value, then delete page from cache without flush,
+  on the disk should be page with old content written during preparation
+*/
+
+int simple_delete_forget_test()
+{
+  unsigned char *buffw= malloc(PAGE_SIZE);
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  int res;
+  DBUG_ENTER("simple_delete_forget_test");
+  /* prepare the file */
+  bfill(buffw, PAGE_SIZE, '\1');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_UNLOCKED,
+                  PAGECACHE_PIN_LEFT_UNPINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  /* test */
+  bfill(buffw, PAGE_SIZE, '\2');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_UNLOCKED,
+                  PAGECACHE_PIN_LEFT_UNPINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  pagecache_delete_page(&pagecache, &file1, 0,
+                        PAGECACHE_LOCK_WRITE, 0);
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  ok((res= test(test_file(file1, file1_name, PAGE_SIZE, PAGE_SIZE,
+                          simple_delete_forget_test_file))),
+     "Simple delete-forget page file");
+  if (res)
+    reset_file(file1, file1_name);
+  free(buffw);
+  free(buffr);
+  DBUG_RETURN(res);
+}
+
+/*
+  Prepare page with locking, write new content to the page,
+  delete page with flush and on existing lock,
+  check that page on disk contain new value.
+*/
+
+int simple_delete_flush_test()
+{
+  unsigned char *buffw= malloc(PAGE_SIZE);
+  unsigned char *buffr= malloc(PAGE_SIZE);
+  int res;
+  DBUG_ENTER("simple_delete_flush_test");
+  /* prepare the file */
+  bfill(buffw, PAGE_SIZE, '\1');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_WRITE,
+                  PAGECACHE_PIN,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  /* test */
+  bfill(buffw, PAGE_SIZE, '\2');
+  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+                  PAGECACHE_PLAIN_PAGE,
+                  PAGECACHE_LOCK_LEFT_WRITELOCKED,
+                  PAGECACHE_PIN_LEFT_PINNED,
+                  PAGECACHE_WRITE_DELAY,
+                  0);
+  pagecache_delete_page(&pagecache, &file1, 0,
+                        PAGECACHE_LOCK_LEFT_WRITELOCKED, 1);
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+  ok((res= test(test_file(file1, file1_name, PAGE_SIZE, PAGE_SIZE,
+                          simple_delete_flush_test_file))),
+     "Simple delete-forget page file");
+  if (res)
+    reset_file(file1, file1_name);
+  free(buffw);
+  free(buffr);
+  DBUG_RETURN(res);
+}
+
+
+/*
+  write then read file bigger then cache
+*/
+
+int simple_big_test()
+{
+  unsigned char *buffw= (unsigned char *)malloc(PAGE_SIZE);
+  unsigned char *buffr= (unsigned char *)malloc(PAGE_SIZE);
+  struct file_desc *desc=
+    (struct file_desc *)malloc((PCACHE_SIZE/(PAGE_SIZE/2)) *
+                               sizeof(struct file_desc));
+  int res, i;
+  DBUG_ENTER("simple_big_test");
+  /* prepare the file twice larger then cache */
+  for (i= 0; i < PCACHE_SIZE/(PAGE_SIZE/2); i++)
+  {
+    bfill(buffw, PAGE_SIZE, (unsigned char) (i & 0xff));
+    desc[i].length= PAGE_SIZE;
+    desc[i].content= (i & 0xff);
+    pagecache_write(&pagecache, &file1, i, 3, (char*)buffw,
+                    PAGECACHE_PLAIN_PAGE,
+                    PAGECACHE_LOCK_LEFT_UNLOCKED,
+                    PAGECACHE_PIN_LEFT_UNPINNED,
+                    PAGECACHE_WRITE_DELAY,
+                    0);
+  }
+  ok(1, "Simple big file write");
+  /* check written pages sequentally read */
+  for (i= 0; i < PCACHE_SIZE/(PAGE_SIZE/2); i++)
+  {
+    int j;
+    pagecache_read(&pagecache, &file1, i, 3, (char*)buffr,
+                   PAGECACHE_PLAIN_PAGE,
+                   PAGECACHE_LOCK_LEFT_UNLOCKED,
+                   0);
+    for(j= 0; j < PAGE_SIZE; j++)
+    {
+      if (buffr[j] != (i & 0xff))
+      {
+        diag("simple_big_test seq: page %u byte %u mismatch\n", i, j);
+        return 0;
+      }
+    }
+  }
+  ok(1, "simple big file sequentally read");
+  /* chack random reads */
+  for (i= 0; i < PCACHE_SIZE/(PAGE_SIZE); i++)
+  {
+    int j, page;
+    page= rand() % (PCACHE_SIZE/(PAGE_SIZE/2));
+    pagecache_read(&pagecache, &file1, page, 3, (char*)buffr,
+                   PAGECACHE_PLAIN_PAGE,
+                   PAGECACHE_LOCK_LEFT_UNLOCKED,
+                   0);
+    for(j= 0; j < PAGE_SIZE; j++)
+    {
+      if (buffr[j] != (page & 0xff))
+      {
+        diag("simple_big_test rnd: page %u byte %u mismatch\n", page, j);
+        return 0;
+      }
+    }
+  }
+  ok(1, "simple big file random read");
+  flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
+
+  ok((res= test(test_file(file1, file1_name, PCACHE_SIZE*2, PAGE_SIZE,
+                          desc))),
+     "Simple big file");
+  if (res)
+    reset_file(file1, file1_name);
+  free(buffw);
+  free(buffr);
+  DBUG_RETURN(res);
+}
+/*
+  Thread function
+*/
+
+static void *test_thread(void *arg)
+{
+  int param=*((int*) arg);
+
+  my_thread_init();
+  DBUG_ENTER("test_thread");
+
+  DBUG_PRINT("enter", ("param: %d", param));
+
+  if (!simple_read_write_test() ||
+      !simple_read_change_write_read_test() ||
+      !simple_pin_test() ||
+      !simple_delete_forget_test() ||
+      !simple_delete_flush_test() ||
+      !simple_big_test())
+    exit(1);
+
+  DBUG_PRINT("info", ("Thread %s ended\n", my_thread_name()));
+  pthread_mutex_lock(&LOCK_thread_count);
+  thread_count--;
+  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_mutex_unlock(&LOCK_thread_count);
+  free((gptr) arg);
+  my_thread_end();
+  DBUG_RETURN(0);
+}
+
+
+int main(int argc, char **argv __attribute__((unused)))
+{
+  pthread_t tid;
+  pthread_attr_t thr_attr;
+  int *param, error, pagen;
+
+  MY_INIT(argv[0]);
+
+#ifndef DBUG_OFF
+#if defined(__WIN__)
+  default_dbug_option= "d:t:i:O,\\test_pagecache_single.trace";
+#else
+  default_dbug_option= "d:t:i:o,/tmp/test_pagecache_single.trace";
+#endif
+  if (argc > 1)
+  {
+    DBUG_SET(default_dbug_option);
+    DBUG_SET_INITIAL(default_dbug_option);
+  }
+#endif
+
+
+  DBUG_ENTER("main");
+  DBUG_PRINT("info", ("Main thread: %s\n", my_thread_name()));
+  if ((file1.file= my_open(file1_name,
+                           O_CREAT | O_TRUNC | O_RDWR, MYF(0))) == -1)
+  {
+    fprintf(stderr, "Got error during file1 creation from open() (errno: %d)\n",
+	    errno);
+    exit(1);
+  }
+  DBUG_PRINT("info", ("file1: %d", file1.file));
+  if (chmod(file1_name, S_IRWXU | S_IRWXG | S_IRWXO) != 0)
+  {
+    fprintf(stderr, "Got error during file1 chmod() (errno: %d)\n",
+	    errno);
+    exit(1);
+  }
+  my_pwrite(file1.file, "test file", 9, 0, MYF(0));
+
+  if ((error= pthread_cond_init(&COND_thread_count, NULL)))
+  {
+    fprintf(stderr, "Got error: %d from pthread_cond_init (errno: %d)\n",
+	    error, errno);
+    exit(1);
+  }
+  if ((error= pthread_mutex_init(&LOCK_thread_count, MY_MUTEX_INIT_FAST)))
+  {
+    fprintf(stderr, "Got error: %d from pthread_cond_init (errno: %d)\n",
+	    error, errno);
+    exit(1);
+  }
+
+  if ((error= pthread_attr_init(&thr_attr)))
+  {
+    fprintf(stderr,"Got error: %d from pthread_attr_init (errno: %d)\n",
+	    error,errno);
+    exit(1);
+  }
+  if ((error= pthread_attr_setdetachstate(&thr_attr, PTHREAD_CREATE_DETACHED)))
+  {
+    fprintf(stderr,
+	    "Got error: %d from pthread_attr_setdetachstate (errno: %d)\n",
+	    error,errno);
+    exit(1);
+  }
+
+#ifndef pthread_attr_setstacksize		/* void return value */
+  if ((error= pthread_attr_setstacksize(&thr_attr, 65536L)))
+  {
+    fprintf(stderr,"Got error: %d from pthread_attr_setstacksize (errno: %d)\n",
+	    error,errno);
+    exit(1);
+  }
+#endif
+#ifdef HAVE_THR_SETCONCURRENCY
+  VOID(thr_setconcurrency(2));
+#endif
+
+  my_thread_global_init();
+
+  plan(12);
+
+  if ((pagen= init_pagecache(&pagecache, PCACHE_SIZE, 0, 0,
+                             PAGE_SIZE, 0)) == 0)
+  {
+    fprintf(stderr,"Got error: init_pagecache() (errno: %d)\n",
+            errno);
+    exit(1);
+  }
+  DBUG_PRINT("info", ("Page cache %d pages", pagen));
+
+  if ((error=pthread_mutex_lock(&LOCK_thread_count)))
+  {
+    fprintf(stderr,"Got error: %d from pthread_mutex_lock (errno: %d)\n",
+            error,errno);
+    exit(1);
+  }
+  param=(int*) malloc(sizeof(int));
+  *param= 1;
+  if ((error= pthread_create(&tid, &thr_attr, test_thread, (void*) param)))
+  {
+    fprintf(stderr,"Got error: %d from pthread_create (errno: %d)\n",
+            error,errno);
+    exit(1);
+  }
+  thread_count++;
+  DBUG_PRINT("info", ("Thread started"));
+  pthread_mutex_unlock(&LOCK_thread_count);
+
+  pthread_attr_destroy(&thr_attr);
+
+  if ((error= pthread_mutex_lock(&LOCK_thread_count)))
+    fprintf(stderr,"Got error: %d from pthread_mutex_lock\n",error);
+  while (thread_count)
+  {
+    if ((error= pthread_cond_wait(&COND_thread_count,&LOCK_thread_count)))
+      fprintf(stderr,"Got error: %d from pthread_cond_wait\n",error);
+  }
+  if ((error= pthread_mutex_unlock(&LOCK_thread_count)))
+    fprintf(stderr,"Got error: %d from pthread_mutex_unlock\n",error);
+  DBUG_PRINT("info", ("thread ended"));
+
+  end_pagecache(&pagecache, 1);
+  DBUG_PRINT("info", ("Page cache ended"));
+
+  if (my_close(file1.file, MYF(0)) != 0)
+  {
+    fprintf(stderr, "Got error during file1 closing from close() (errno: %d)\n",
+	    errno);
+    exit(1);
+  }
+  /*my_delete(file1_name, MYF(0));*/
+  my_thread_global_end();
+
+  DBUG_PRINT("info", ("file1 (%d) closed", file1.file));
+
+  DBUG_PRINT("info", ("Program end"));
+
+  DBUG_RETURN(exit_status());
+}
diff --git a/unittest/mysys/my_atomic-t.c b/unittest/mysys/my_atomic-t.c
index fe93b0942ce..02e07acd67b 100644
--- a/unittest/mysys/my_atomic-t.c
+++ b/unittest/mysys/my_atomic-t.c
@@ -14,27 +14,27 @@
    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;
+volatile int32  c32, N;
 my_atomic_rwlock_t rwl;
-
-pthread_attr_t thr_attr;
-pthread_mutex_t mutex;
-pthread_cond_t cond;
-int N;
+LF_ALLOCATOR lf_allocator;
+LF_HASH lf_hash;
 
 /* 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);
@@ -43,10 +43,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;
 }
 
@@ -58,30 +54,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;
-
-  my_atomic_rwlock_wrlock(&rwl);
-  x=my_atomic_add32(&b32, 1);
-  my_atomic_rwlock_wrunlock(&rwl);
+  int    m= *(int *)arg;
+  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--)
   {
     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);
   }
 
@@ -89,105 +79,220 @@ 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;
-  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);
+    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) ;
+  }
+  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);
+  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);
+
+  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_stack);
+#ifdef MY_LF_EXTRA_DEBUG
+    a32|= lf_allocator.mallocs - lf_alloc_in_pool(&lf_allocator);
+#endif
   }
-  pthread_mutex_lock(&mutex);
-  N--;
-  if (!N) pthread_cond_signal(&cond);
-  pthread_mutex_unlock(&mutex);
+  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);
+
+  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_stack,
+         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;
+  for (i= 0 ; i < n ; i++)
+    pthread_join(threads[i], 0);
+  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);
+  my_free((void *)threads, MYF(0));
 }
 
 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);
-  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 MY_ATOMIC_MODE_RWLOCKS
+#define CYCLES 3000
+#else
+#define CYCLES 300000
+#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_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);
 
-  /*
-    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();
 }
 
diff --git a/unittest/mysys/test_file.c b/unittest/mysys/test_file.c
new file mode 100644
index 00000000000..758d0bfa81b
--- /dev/null
+++ b/unittest/mysys/test_file.c
@@ -0,0 +1,68 @@
+#include <tap.h>
+#include <my_sys.h>
+#include <my_dir.h>
+#include "test_file.h"
+
+
+/*
+  Check that file contance correspond to descriptor
+
+  SYNOPSIS
+    test_file()
+    file                 File to test
+    file_name            Path (and name) of file which is tested
+    size                 size of file
+    buff_size            size of buffer which is enought to check the file
+    desc                 file descriptor to check with
+
+  RETURN
+    1 file if OK
+    0 error
+*/
+
+int test_file(PAGECACHE_FILE file, char *file_name,
+              off_t size, size_t buff_size, struct file_desc *desc)
+{
+  MY_STAT stat_buff, *stat;
+  unsigned char *buffr= malloc(buff_size);
+  off_t pos= 0;
+  size_t byte;
+  int step= 0;
+
+  if ((stat= my_stat(file_name, &stat_buff, MYF(0))) == NULL)
+  {
+    diag("Can't stat() %s (errno: %d)\n", file_name, errno);
+    return 0;
+  }
+  if (stat->st_size != size)
+  {
+    diag("file %s size is %lu (should be %lu)\n",
+         file_name, (ulong) stat->st_size, (ulong) size);
+    return 0;
+  }
+  /* check content */
+  my_seek(file.file, 0, SEEK_SET, MYF(0));
+  while (desc[step].length != 0)
+  {
+    if (my_read(file.file, (char*)buffr, desc[step].length, MYF(0)) !=
+        desc[step].length)
+    {
+      diag("Can't read %u bytes from %s (errno: %d)\n",
+           (uint)desc[step].length, file_name, errno);
+      return 0;
+    }
+    for (byte= 0; byte < desc[step].length; byte++)
+    {
+      if (buffr[byte] != desc[step].content)
+      {
+        diag("content of %s mismatch 0x%x in position %lu instead of 0x%x\n",
+             file_name, (uint) buffr[byte], (ulong) (pos + byte),
+             desc[step].content);
+        return 0;
+      }
+    }
+    pos+= desc[step].length;
+    step++;
+  }
+  return 1;
+}
diff --git a/unittest/mysys/test_file.h b/unittest/mysys/test_file.h
new file mode 100644
index 00000000000..bfc660b13d0
--- /dev/null
+++ b/unittest/mysys/test_file.h
@@ -0,0 +1,14 @@
+#include <m_string.h>
+#include <pagecache.h>
+
+/*
+  File content descriptor
+*/
+struct file_desc
+{
+  unsigned int length;
+  unsigned char content;
+};
+
+int test_file(PAGECACHE_FILE file, char *file_name,
+              off_t size, size_t buff_size, struct file_desc *desc);
diff --git a/unittest/mytap/tap.c b/unittest/mytap/tap.c
index 54292f3b828..b7d09666246 100644
--- a/unittest/mytap/tap.c
+++ b/unittest/mytap/tap.c
@@ -158,6 +158,8 @@ static signal_entry install_signal[]= {
 void
 plan(int const count)
 {
+
+  setvbuf(tapout, 0, _IONBF, 0);  /* provide output at once */
   /*
     Install signal handler
   */