Merge desktop.sanja.is.com.ua:/home/bell/mysql/bk/mysql-maria

into  desktop.sanja.is.com.ua:/home/bell/mysql/bk/work-maria-pagecache


mysys/Makefile.am:
  Auto merged
mysys/mf_keycache.c:
  Auto merged
storage/maria/Makefile.am:
  Auto merged
storage/maria/unittest/ma_control_file-t.c:
  Auto merged
storage/maria/unittest/mf_pagecache_consist.c:
  Auto merged
storage/maria/unittest/mf_pagecache_single.c:
  Auto merged
storage/maria/unittest/test_file.h:
  Auto merged
include/pagecache.h:
  merge
mysys/mf_pagecache.c:
  merge
storage/maria/maria_def.h:
  merge
storage/maria/unittest/Makefile.am:
  merge
unittest/mysys/Makefile.am:
  merge

5 files changed, 0 insertions, 1143 deletions

diff --git a/unittest/mysys/Makefile.am b/unittest/mysys/Makefile.am
index f7b72255a72..796dd892f1f 100644
--- a/unittest/mysys/Makefile.am
+++ b/unittest/mysys/Makefile.am
@@ -6,53 +6,3 @@ LDADD 		= $(top_builddir)/unittest/mytap/libmytap.a \
 		  $(top_builddir)/mysys/libmysys.a \
 		  $(top_builddir)/dbug/libdbug.a \
 		  $(top_builddir)/strings/libmystrings.a
-
-# 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
deleted file mode 100755
index fd824e27051..00000000000
--- a/unittest/mysys/mf_pagecache_consist.c
+++ /dev/null
@@ -1,434 +0,0 @@
-/*
-  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, (byte*) 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);
-  }
-
-#ifdef HAVE_THR_SETCONCURRENCY
-  VOID(thr_setconcurrency(2));
-#endif
-
-  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_end(0);
-
-  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
deleted file mode 100644
index 4fadf2a554f..00000000000
--- a/unittest/mysys/mf_pagecache_single.c
+++ /dev/null
@@ -1,577 +0,0 @@
-/*
-  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);
-  }
-
-#ifdef HAVE_THR_SETCONCURRENCY
-  VOID(thr_setconcurrency(2));
-#endif
-
-  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_end(0);
-
-  DBUG_PRINT("info", ("file1 (%d) closed", file1.file));
-
-  DBUG_PRINT("info", ("Program end"));
-
-  DBUG_RETURN(exit_status());
-}
diff --git a/unittest/mysys/test_file.c b/unittest/mysys/test_file.c
deleted file mode 100644
index 758d0bfa81b..00000000000
--- a/unittest/mysys/test_file.c
+++ /dev/null
@@ -1,68 +0,0 @@
-#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
deleted file mode 100644
index bfc660b13d0..00000000000
--- a/unittest/mysys/test_file.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#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);