Patch for push of wl1354 Partitioning

3 files changed, 405 insertions, 34 deletions

diff --git a/mysys/Makefile.am b/mysys/Makefile.am
index 41a8a3e647a..ad075f3324a 100644
--- a/mysys/Makefile.am
+++ b/mysys/Makefile.am
@@ -84,6 +84,9 @@ FLAGS=$(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) @NOINST_LDFLAGS@
 test_bitmap$(EXEEXT): my_bitmap.c $(LIBRARIES)
 	$(LINK) $(FLAGS) -DMAIN  ./my_bitmap.c $(LDADD) $(LIBS)
 
+test_priority_queue$(EXEEXT): queues.c $(LIBRARIES)
+	$(LINK) $(FLAGS) -DMAIN  ./queues.c $(LDADD) $(LIBS)
+
 test_thr_alarm$(EXEEXT): thr_alarm.c $(LIBRARIES)
 	$(CP) $(srcdir)/thr_alarm.c ./test_thr_alarm.c
 	$(LINK) $(FLAGS) -DMAIN  ./test_thr_alarm.c $(LDADD) $(LIBS)
diff --git a/mysys/my_bitmap.c b/mysys/my_bitmap.c
index 490a476691d..b5f928fee1e 100644
--- a/mysys/my_bitmap.c
+++ b/mysys/my_bitmap.c
@@ -20,20 +20,20 @@
   API limitations (or, rather asserted safety assumptions,
   to encourage correct programming)
 
-    * the size of the used bitmap is less than ~(uint) 0
-    * it's a multiple of 8 (for efficiency reasons)
-    * when arguments are a bitmap and a bit number, the number
-      must be within bitmap size
-    * bitmap_set_prefix() is an exception - one can use ~0 to set all bits
-    * when both arguments are bitmaps, they must be of the same size
-    * bitmap_intersect() is an exception :)
-      (for for Bitmap::intersect(ulonglong map2buff))
-
-  If THREAD is defined all bitmap operations except bitmap_init/bitmap_free
-  are thread-safe.
+    * the internal size is a set of 32 bit words
+    * the number of bits specified in creation can be any number > 0
+    * there are THREAD safe versions of most calls called bitmap_lock_*
+      many of those are not used and not compiled normally but the code
+      already exist for them in an #ifdef:ed part. These can only be used
+      if THREAD was specified in bitmap_init
 
   TODO:
   Make assembler THREAD safe versions of these using test-and-set instructions
+
+  Original version created by Sergei Golubchik 2001 - 2004.
+  New version written and test program added and some changes to the interface
+  was made by Mikael Ronström 2005, with assistance of Tomas Ulin and Mats
+  Kindahl.
 */
 
 #include "mysys_priv.h"
@@ -1046,17 +1046,9 @@ int main()
 }
 
 /*
-This is the way the test part was compiled after a complete tree build with
-debug.
-
-gcc -DHAVE_CONFIG_H -I. -I. -I.. -I../include -I.    -g -O -DDBUG_ON
--DSAFE_MUTEX -fno-omit-frame-pointer   -DHAVE_DARWIN_THREADS
--D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE -DTEST_BITMAP
--DSIGNALS_DONT_BREAK_READ -DIGNORE_SIGHUP_SIGQUIT -MT
-my_bitmap.o -MD -MP -MF ".deps/my_bitmap.Tpo" -c -o my_bitmap.o my_bitmap.c
-
-gcc -o my_bitmap my_bitmap.o -L../mysys -lmysys -L../strings -lmystrings
--L../dbug -ldbug
+  In directory mysys:
+  make test_bitmap
+  will build the bitmap tests and ./test_bitmap will execute it
 */
 
 #endif
diff --git a/mysys/queues.c b/mysys/queues.c
index ecf1058af41..0e4e251f7e7 100644
--- a/mysys/queues.c
+++ b/mysys/queues.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000 MySQL AB
+/* Copyright (C) 2000, 2005 MySQL AB
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -17,6 +17,10 @@
 /*
   Code for generell handling of priority Queues.
   Implemention of queues from "Algoritms in C" by Robert Sedgewick.
+  An optimisation of _downheap suggested in Exercise 7.51 in "Data
+  Structures & Algorithms in C++" by Mark Allen Weiss, Second Edition
+  was implemented by Mikael Ronström 2005. Also the O(N) algorithm
+  of queue_fix was implemented.
 */
 
 #include "mysys_priv.h"
@@ -214,8 +218,64 @@ void queue_replaced(QUEUE *queue)
 }
 #endif
 
-	/* Fix heap when index have changed */
+#ifndef OLD_VERSION
+
+void _downheap(register QUEUE *queue, uint idx)
+{
+  byte *element;
+  uint elements,half_queue,offset_to_key, next_index;
+  bool first= TRUE;
+  uint start_idx= idx;
+
+  offset_to_key=queue->offset_to_key;
+  element=queue->root[idx];
+  half_queue=(elements=queue->elements) >> 1;
+
+  while (idx <= half_queue)
+  {
+    int cmp;
+    next_index=idx+idx;
+    if (next_index < elements &&
+	(queue->compare(queue->first_cmp_arg,
+			queue->root[next_index]+offset_to_key,
+			queue->root[next_index+1]+offset_to_key) ^
+	 queue->max_at_top) > 0)
+      next_index++;
+    if (first && 
+        (((cmp=queue->compare(queue->first_cmp_arg,
+                              queue->root[next_index]+offset_to_key,
+                              element+offset_to_key)) == 0) ||
+	 ((cmp ^ queue->max_at_top) > 0)))
+    {
+      queue->root[idx]= element;
+      return;
+    }
+    queue->root[idx]=queue->root[next_index];
+    idx=next_index;
+    first= FALSE;
+  }
+
+  next_index= idx >> 1;
+  while (next_index > start_idx)
+  {
+    if ((queue->compare(queue->first_cmp_arg,
+                       queue->root[next_index]+offset_to_key,
+                       element+offset_to_key) ^
+         queue->max_at_top) < 0)
+      break;
+    queue->root[idx]=queue->root[next_index];
+    idx=next_index;
+    next_index= idx >> 1;
+  }
+  queue->root[idx]=element;
+}
 
+#else
+  /*
+    The old _downheap version is kept for comparisons with the benchmark
+    suit or new benchmarks anyone wants to run for comparisons.
+  */
+	/* Fix heap when index have changed */
 void _downheap(register QUEUE *queue, uint idx)
 {
   byte *element;
@@ -247,20 +307,336 @@ void _downheap(register QUEUE *queue, uint idx)
 }
 
 
-static int queue_fix_cmp(QUEUE *queue, void **a, void **b)
-{
-  return queue->compare(queue->first_cmp_arg,
-			(byte*) (*a)+queue->offset_to_key,
-			(byte*) (*b)+queue->offset_to_key);
-}
+#endif
 
 /*
-  Fix heap when every element was changed,
-  actually, it can be done better, in linear time, not in n*log(n)
+  Fix heap when every element was changed.
 */
 
 void queue_fix(QUEUE *queue)
 {
-  qsort2(queue->root+1,queue->elements, sizeof(void *),
-	 (qsort2_cmp)queue_fix_cmp, queue);
+  uint i;
+  for (i= queue->elements >> 1; i > 0; i--)
+    _downheap(queue, i);
+}
+
+#ifdef MAIN
+ /*
+   A test program for the priority queue implementation.
+   It can also be used to benchmark changes of the implementation
+   Build by doing the following in the directory mysys
+   make test_priority_queue
+   ./test_priority_queue
+
+   Written by Mikael Ronström, 2005
+ */
+
+static uint num_array[1025];
+static uint tot_no_parts= 0;
+static uint tot_no_loops= 0;
+static uint expected_part= 0;
+static uint expected_num= 0;
+static bool max_ind= 0;
+static bool fix_used= 0;
+static ulonglong start_time= 0;
+
+static bool is_divisible_by(uint num, uint divisor)
+{
+  uint quotient= num / divisor;
+  if (quotient * divisor == num)
+    return TRUE;
+  return FALSE;
+}
+
+void calculate_next()
+{
+  uint part= expected_part, num= expected_num;
+  uint no_parts= tot_no_parts;
+  if (max_ind)
+  {
+    do
+    {
+      while (++part <= no_parts)
+      {
+        if (is_divisible_by(num, part) &&
+            (num <= ((1 << 21) + part)))
+        {
+          expected_part= part;
+          expected_num= num;
+          return;
+        }
+      }
+      part= 0;
+    } while (--num);
+  }
+  else
+  {
+    do
+    {
+      while (--part > 0)
+      {
+        if (is_divisible_by(num, part))
+        {
+          expected_part= part;
+          expected_num= num;
+          return;
+        }
+      }
+      part= no_parts + 1;
+    } while (++num);
+  }
+}
+
+void calculate_end_next(uint part)
+{
+  uint no_parts= tot_no_parts, num;
+  num_array[part]= 0;
+  if (max_ind)
+  {
+    expected_num= 0;
+    for (part= no_parts; part > 0 ; part--)
+    {
+      if (num_array[part])
+      {
+        num= num_array[part] & 0x3FFFFF;
+        if (num >= expected_num)
+        {
+          expected_num= num;
+          expected_part= part;
+        }
+      }
+    }
+    if (expected_num == 0)
+      expected_part= 0;
+  }
+  else
+  {
+    expected_num= 0xFFFFFFFF;
+    for (part= 1; part <= no_parts; part++)
+    {
+      if (num_array[part])
+      {
+        num= num_array[part] & 0x3FFFFF;
+        if (num <= expected_num)
+        {
+          expected_num= num;
+          expected_part= part;
+        }
+      }
+    }
+    if (expected_num == 0xFFFFFFFF)
+      expected_part= 0;
+  }
+  return;
+}
+static int test_compare(void *null_arg, byte *a, byte *b)
+{
+  uint a_num= (*(uint*)a) & 0x3FFFFF;
+  uint b_num= (*(uint*)b) & 0x3FFFFF;
+  uint a_part, b_part;
+  if (a_num > b_num)
+    return +1;
+  if (a_num < b_num)
+    return -1;
+  a_part= (*(uint*)a) >> 22;
+  b_part= (*(uint*)b) >> 22;
+  if (a_part < b_part)
+    return +1;
+  if (a_part > b_part)
+    return -1;
+  return 0;
+}
+
+bool check_num(uint num_part)
+{
+  uint part= num_part >> 22;
+  uint num= num_part & 0x3FFFFF;
+  if (part == expected_part)
+    if (num == expected_num)
+      return FALSE;
+  printf("Expect part %u Expect num 0x%x got part %u num 0x%x max_ind %u fix_used %u \n",
+          expected_part, expected_num, part, num, max_ind, fix_used);
+  return TRUE;
+}
+
+
+void perform_insert(QUEUE *queue)
+{
+  uint i= 1, no_parts= tot_no_parts;
+  uint backward_start= 0;
+
+  expected_part= 1;
+  expected_num= 1;
+ 
+  if (max_ind)
+    backward_start= 1 << 21;
+
+  do
+  {
+    uint num= (i + backward_start);
+    if (max_ind)
+    {
+      while (!is_divisible_by(num, i))
+        num--;
+      if (max_ind && (num > expected_num ||
+                      (num == expected_num && i < expected_part)))
+      {
+        expected_num= num;
+        expected_part= i;
+      }
+    }
+    num_array[i]= num + (i << 22);
+    if (fix_used)
+      queue_element(queue, i-1)= (byte*)&num_array[i];
+    else
+      queue_insert(queue, (byte*)&num_array[i]);
+  } while (++i <= no_parts);
+  if (fix_used)
+  {
+    queue->elements= no_parts;
+    queue_fix(queue);
+  }
+}
+
+bool perform_ins_del(QUEUE *queue, bool max_ind)
+{
+  uint i= 0, no_loops= tot_no_loops, j= tot_no_parts;
+  do
+  {
+    uint num_part= *(uint*)queue_top(queue);
+    uint part= num_part >> 22;
+    if (check_num(num_part))
+      return TRUE;
+    if (j++ >= no_loops)
+    {
+      calculate_end_next(part);
+      queue_remove(queue, (uint) 0);
+    }
+    else
+    {
+      calculate_next();
+      if (max_ind)
+        num_array[part]-= part;
+      else
+        num_array[part]+= part;
+      queue_top(queue)= (byte*)&num_array[part];
+      queue_replaced(queue);
+    }
+  } while (++i < no_loops);
+  return FALSE;
+}
+
+bool do_test(uint no_parts, uint l_max_ind, bool l_fix_used)
+{
+  QUEUE queue;
+  bool result;
+  max_ind= l_max_ind;
+  fix_used= l_fix_used;
+  init_queue(&queue, no_parts, 0, max_ind, test_compare, NULL);
+  tot_no_parts= no_parts;
+  tot_no_loops= 1024;
+  perform_insert(&queue);
+  if ((result= perform_ins_del(&queue, max_ind)))
+  delete_queue(&queue);
+  if (result)
+  {
+    printf("Error\n");
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static void start_measurement()
+{
+  start_time= my_getsystime();
+}
+
+static void stop_measurement()
+{
+  ulonglong stop_time= my_getsystime();
+  uint time_in_micros;
+  stop_time-= start_time;
+  stop_time/= 10; /* Convert to microseconds */
+  time_in_micros= (uint)stop_time;
+  printf("Time expired is %u microseconds \n", time_in_micros);
+}
+
+static void benchmark_test()
+{
+  QUEUE queue_real;
+  QUEUE *queue= &queue_real;
+  uint i, add;
+  fix_used= TRUE;
+  max_ind= FALSE;
+  tot_no_parts= 1024;
+  init_queue(queue, tot_no_parts, 0, max_ind, test_compare, NULL);
+  /*
+    First benchmark whether queue_fix is faster than using queue_insert
+    for sizes of 16 partitions.
+  */
+  for (tot_no_parts= 2, add=2; tot_no_parts < 128;
+       tot_no_parts+= add, add++)
+  {
+    printf("Start benchmark queue_fix, tot_no_parts= %u \n", tot_no_parts);
+    start_measurement();
+    for (i= 0; i < 128; i++)
+    {
+      perform_insert(queue);
+      queue_remove_all(queue);
+    }
+    stop_measurement();
+
+    fix_used= FALSE;
+    printf("Start benchmark queue_insert\n");
+    start_measurement();
+    for (i= 0; i < 128; i++)
+    {
+      perform_insert(queue);
+      queue_remove_all(queue);
+    }
+    stop_measurement();
+  }
+  /*
+    Now benchmark insertion and deletion of 16400 elements.
+    Used in consecutive runs this shows whether the optimised _downheap
+    is faster than the standard implementation.
+  */
+  printf("Start benchmarking _downheap \n");
+  start_measurement();
+  perform_insert(queue);
+  for (i= 0; i < 65536; i++)
+  {
+    uint num, part;
+    num= *(uint*)queue_top(queue);
+    num+= 16;
+    part= num >> 22;
+    num_array[part]= num;
+    queue_top(queue)= (byte*)&num_array[part];
+    queue_replaced(queue);
+  }
+  for (i= 0; i < 16; i++)
+    queue_remove(queue, (uint) 0);
+  queue_remove_all(queue);
+  stop_measurement();
+}
+
+int main()
+{
+  int i, add= 1;
+  for (i= 1; i < 1024; i+=add, add++)
+  {
+    printf("Start test for priority queue of size %u\n", i);
+    if (do_test(i, 0, 1))
+      return -1;
+    if (do_test(i, 1, 1))
+      return -1;
+    if (do_test(i, 0, 0))
+      return -1;
+    if (do_test(i, 1, 0))
+      return -1;
+  }
+  benchmark_test();
+  printf("OK\n");
+  return 0;
 }
+#endif