fixes to Bitmap class

1 files changed, 78 insertions, 97 deletions

diff --git a/mysys/my_bitmap.c b/mysys/my_bitmap.c
index 70b15eaa1d8..af9b3843060 100644
--- a/mysys/my_bitmap.c
+++ b/mysys/my_bitmap.c
@@ -30,63 +30,67 @@
 inline void bitmap_lock(MY_BITMAP *map)
 {
 #ifdef THREAD
-  if (map->thread_safe)
-    pthread_mutex_lock(&map->mutex);
+  if (map->mutex)
+    pthread_mutex_lock(map->mutex);
 #endif
 }
 
 inline void bitmap_unlock(MY_BITMAP *map)
 {
 #ifdef THREAD
-  if (map->thread_safe)
-    pthread_mutex_unlock(&map->mutex);
+  if (map->mutex)
+    pthread_mutex_unlock(map->mutex);
 #endif
 }
 
 my_bool bitmap_init(MY_BITMAP *map, uchar *buf, uint bitmap_size, my_bool thread_safe)
 {
+  // for efficiency reasons - MY_BITMAP is heavily used
+  DBUG_ASSERT((bitmap_size & 7) == 0);
+  bitmap_size/=8;
   if (!(map->bitmap=buf) &&
-      !(map->bitmap=(uchar*) my_malloc((bitmap_size+7)/8,
-				       MYF(MY_WME | MY_ZEROFILL))))
+       !(map->bitmap=(uchar*)my_malloc(bitmap_size + sizeof(pthread_mutex_t),
+                                       MYF(MY_WME | MY_ZEROFILL))))
     return 1;
-  DBUG_ASSERT(bitmap_size != ~(uint) 0);
+  map->bitmap_size=bitmap_size;
 #ifdef THREAD
-  if ((map->thread_safe = thread_safe))
-    pthread_mutex_init(&map->mutex, MY_MUTEX_INIT_FAST);
+  if (thread_safe)
+  {
+    map->mutex=(pthread_mutex_t *)(map->bitmap+bitmap_size);
+    pthread_mutex_init(map->mutex, MY_MUTEX_INIT_FAST);
+  }
+  else
+    map->mutex=0;
 #endif
-  map->bitmap_size=bitmap_size;
   return 0;
 }
 
 void bitmap_free(MY_BITMAP *map)
 {
+#ifdef THREAD
+  if (map->mutex)
+    pthread_mutex_destroy(map->mutex);
+#endif
   if (map->bitmap)
   {
     my_free((char*) map->bitmap, MYF(0));
     map->bitmap=0;
-#ifdef THREAD
-    if (map->thread_safe)
-      pthread_mutex_destroy(&map->mutex);
-#endif
   }
 }
 
 void bitmap_set_bit(MY_BITMAP *map, uint bitmap_bit)
 {
-  DBUG_ASSERT(map->bitmap);
-  if (bitmap_bit < map->bitmap_size)
-  {
-    bitmap_lock(map);
-    map->bitmap[bitmap_bit / 8] |= (1 << (bitmap_bit & 7));
-    bitmap_unlock(map);
-  }
+  DBUG_ASSERT(map->bitmap && bitmap_bit < map->bitmap_size*8);
+  bitmap_lock(map);
+  map->bitmap[bitmap_bit / 8] |= (1 << (bitmap_bit & 7));
+  bitmap_unlock(map);
 }
 
 uint bitmap_set_next(MY_BITMAP *map)
 {
   uchar *bitmap=map->bitmap;
   uint bit_found = MY_BIT_NONE;
-  uint bitmap_size=map->bitmap_size;
+  uint bitmap_size=map->bitmap_size*8;
   uint i;
 
   DBUG_ASSERT(map->bitmap);
@@ -114,28 +118,25 @@ uint bitmap_set_next(MY_BITMAP *map)
 
 void bitmap_clear_bit(MY_BITMAP *map, uint bitmap_bit)
 {
-  DBUG_ASSERT(map->bitmap);
-  if (bitmap_bit < map->bitmap_size)
-  {
-    bitmap_lock(map);
-    map->bitmap[bitmap_bit / 8] &= ~ (1 << (bitmap_bit & 7));
-    bitmap_unlock(map);
-  }
+  DBUG_ASSERT(map->bitmap && bitmap_bit < map->bitmap_size*8);
+  bitmap_lock(map);
+  map->bitmap[bitmap_bit / 8] &= ~ (1 << (bitmap_bit & 7));
+  bitmap_unlock(map);
 }
 
 void bitmap_set_prefix(MY_BITMAP *map, uint prefix_size)
 {
-  uint l, m;
+  uint prefix_bytes, prefix_bits;
 
   DBUG_ASSERT(map->bitmap);
   bitmap_lock(map);
-  set_if_smaller(prefix_size, map->bitmap_size);
-  if ((l=prefix_size / 8))
-    memset(map->bitmap, 0xff, l);
-  if ((m=prefix_size & 7))
-    map->bitmap[l++]= (1 << m)-1;
-  if (l < (m=(map->bitmap_size+7)/8))
-    bzero(map->bitmap+l, m-l);
+  set_if_smaller(prefix_size, map->bitmap_size*8);
+  if ((prefix_bytes= prefix_size / 8))
+    memset(map->bitmap, 0xff, prefix_bytes);
+  if ((prefix_bits= prefix_size & 7))
+    map->bitmap[prefix_bytes++]= (1 << prefix_bits)-1;
+  if (prefix_bytes < map->bitmap_size)
+    bzero(map->bitmap+prefix_bytes, map->bitmap_size-prefix_bytes);
   bitmap_unlock(map);
 }
 
@@ -146,27 +147,27 @@ void bitmap_clear_all(MY_BITMAP *map)
 
 void bitmap_set_all(MY_BITMAP *map)
 {
-  bitmap_set_prefix(map, map->bitmap_size);
+  bitmap_set_prefix(map, ~0);
 }
 
 my_bool bitmap_is_prefix(MY_BITMAP *map, uint prefix_size)
 {
-  uint l=prefix_size/8, m=prefix_size & 7, i, res=0;
+  uint prefix_bits= prefix_size & 7, res= 0;
+  uchar *m= map->bitmap, *end_prefix= map->bitmap+prefix_size/8,
+        *end= map->bitmap+map->bitmap_size;
 
-  DBUG_ASSERT(map->bitmap);
-  if (prefix_size > map->bitmap_size)
-    return 0;
+  DBUG_ASSERT(map->bitmap && prefix_size <= map->bitmap_size*8);
 
   bitmap_lock(map);
-  for (i=0; i < l; i++)
-    if (map->bitmap[i] != 0xff)
+  while (m < end_prefix)
+    if (*m++ != 0xff)
       goto ret;
 
-  if (m && map->bitmap[i++] != (1 << m)-1)
+  if (prefix_bits && *m++ != (1 << prefix_bits)-1)
     goto ret;
 
-  for (m=(map->bitmap_size+7)/8; i < m; i++)
-    if (map->bitmap[i] != 0)
+  while (m < end)
+    if (m++ != 0)
       goto ret;
 
   res=1;
@@ -182,38 +183,31 @@ my_bool bitmap_is_clear_all(MY_BITMAP *map)
 
 my_bool bitmap_is_set_all(MY_BITMAP *map)
 {
-  return bitmap_is_prefix(map, map->bitmap_size);
+  return bitmap_is_prefix(map, map->bitmap_size*8);
 }
 
 my_bool bitmap_is_set(MY_BITMAP *map, uint bitmap_bit)
 {
-  DBUG_ASSERT(map->bitmap);
-  return (bitmap_bit < map->bitmap_size) ?
-    (map->bitmap[bitmap_bit / 8] & (1 << (bitmap_bit & 7))) : 0;
+  DBUG_ASSERT(map->bitmap && bitmap_bit < map->bitmap_size*8);
+  return map->bitmap[bitmap_bit / 8] & (1 << (bitmap_bit & 7));
 }
 
 my_bool bitmap_is_subset(MY_BITMAP *map1, MY_BITMAP *map2)
 {
-  uint l1, l2, i, res=0;
-  uchar *m1=map1->bitmap, *m2=map2->bitmap;
+  uint length, res=0;
+  uchar *m1=map1->bitmap, *m2=map2->bitmap, *end;
 
-  DBUG_ASSERT(map1->bitmap);
-  DBUG_ASSERT(map2->bitmap);
+  DBUG_ASSERT(map1->bitmap && map2->bitmap &&
+              map1->bitmap_size==map2->bitmap_size);
   bitmap_lock(map1);
   bitmap_lock(map2);
 
-  l1=(map1->bitmap_size+7)/8;
-  l2=(map2->bitmap_size+7)/8;
-  set_if_smaller(l2, l1);
+  end= m1+map1->bitmap_size;
 
-  for (i=0; i < l2; i++)
+  while (m1 < end)
     if ((*m1++) & ~(*m2++))
       goto ret;
 
-  for (; i < l1; i++)
-    if (*m1++)
-      goto ret;
-
   res=1;
 ret:
   bitmap_unlock(map2);
@@ -225,13 +219,12 @@ my_bool bitmap_cmp(MY_BITMAP *map1, MY_BITMAP *map2)
 {
   uint res;
 
-  DBUG_ASSERT(map1->bitmap);
-  DBUG_ASSERT(map2->bitmap);
+  DBUG_ASSERT(map1->bitmap && map2->bitmap &&
+              map1->bitmap_size==map2->bitmap_size);
   bitmap_lock(map1);
   bitmap_lock(map2);
 
-  res= map1->bitmap_size == map2->bitmap_size &&
-       memcmp(map1->bitmap, map2->bitmap, (map1->bitmap_size+7)/8)==0;
+  res= memcmp(map1->bitmap, map2->bitmap, map1->bitmap_size)==0;
 
   bitmap_unlock(map2);
   bitmap_unlock(map1);
@@ -240,23 +233,17 @@ my_bool bitmap_cmp(MY_BITMAP *map1, MY_BITMAP *map2)
 
 void bitmap_intersect(MY_BITMAP *map, MY_BITMAP *map2)
 {
-  uint l1, l2, i;
-  uchar *m=map->bitmap, *m2=map2->bitmap;
+  uchar *to=map->bitmap, *from=map2->bitmap, *end;
 
-  DBUG_ASSERT(map->bitmap);
-  DBUG_ASSERT(map2->bitmap);
+  DBUG_ASSERT(map->bitmap && map2->bitmap &&
+              map->bitmap_size==map2->bitmap_size);
   bitmap_lock(map);
   bitmap_lock(map2);
 
-  l1=(map->bitmap_size+7)/8;
-  l2=(map2->bitmap_size+7)/8;
-  set_if_smaller(l2, l1);
+  end= to+map->bitmap_size;
 
-  for (i=0; i < l2; i++)
-    *m++ &= *m2++;
-
-  if (l1 > l2)
-    bzero(m, l1-l2);
+  while (to < end)
+    *to++ &= *from++;
 
   bitmap_unlock(map2);
   bitmap_unlock(map);
@@ -264,20 +251,17 @@ void bitmap_intersect(MY_BITMAP *map, MY_BITMAP *map2)
 
 void bitmap_subtract(MY_BITMAP *map, MY_BITMAP *map2)
 {
-  uint l1, l2, i;
-  uchar *m=map->bitmap, *m2=map2->bitmap;
+  uchar *to=map->bitmap, *from=map2->bitmap, *end;
 
-  DBUG_ASSERT(map->bitmap);
-  DBUG_ASSERT(map2->bitmap);
+  DBUG_ASSERT(map->bitmap && map2->bitmap &&
+              map->bitmap_size==map2->bitmap_size);
   bitmap_lock(map);
   bitmap_lock(map2);
 
-  l1=(map->bitmap_size+7)/8;
-  l2=(map2->bitmap_size+7)/8;
-  set_if_smaller(l2, l1);
+  end= to+map->bitmap_size;
 
-  for (i=0; i < l2; i++)
-    *m++ &= ~(*m2++);
+  while (to < end)
+    *to++ &= ~(*from++);
 
   bitmap_unlock(map2);
   bitmap_unlock(map);
@@ -285,20 +269,17 @@ void bitmap_subtract(MY_BITMAP *map, MY_BITMAP *map2)
 
 void bitmap_union(MY_BITMAP *map, MY_BITMAP *map2)
 {
-  uint l1, l2, i;
-  uchar *m=map->bitmap, *m2=map2->bitmap;
+  uchar *to=map->bitmap, *from=map2->bitmap, *end;
 
-  DBUG_ASSERT(map->bitmap);
-  DBUG_ASSERT(map2->bitmap);
+  DBUG_ASSERT(map->bitmap && map2->bitmap &&
+              map->bitmap_size==map2->bitmap_size);
   bitmap_lock(map);
   bitmap_lock(map2);
 
-  l1=(map->bitmap_size+7)/8;
-  l2=(map2->bitmap_size+7)/8;
-  set_if_smaller(l2, l1);
+  end= to+map->bitmap_size;
 
-  for (i=0; i < l2; i++)
-    *m++ |= *m2++;
+  while (to < end)
+    *to++ |= *from++;
 
   bitmap_unlock(map2);
   bitmap_unlock(map);