← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_bitmap.c

  • Committer: Brian Aker
  • Date: 2008-07-18 20:10:26 UTC
  • mfrom: (51.3.29 remove-dbug)
  • Revision ID: brian@tangent.org-20080718201026-tto5golt0xhwqe4a
Merging in Jay's final patch on dbug.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_bitmap.c
99
99
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
100
100
                    bool thread_safe __attribute__((unused)))
101
101
{
102
 
  DBUG_ENTER("bitmap_init");
103
102
  if (!buf)
104
103
  {
105
104
    uint size_in_bytes= bitmap_buffer_size(n_bits);
111
110
    }
112
111
    map->mutex= 0;
113
112
    if (!(buf= (my_bitmap_map*) my_malloc(size_in_bytes+extra, MYF(MY_WME))))
114
 
      DBUG_RETURN(1);
 
113
      return(1);
115
114
    if (thread_safe)
116
115
    {
117
116
      map->mutex= (pthread_mutex_t *) ((char*) buf + size_in_bytes);
120
119
  }
121
120
  else
122
121
  {
123
 
    DBUG_ASSERT(thread_safe == 0);
 
122
    assert(thread_safe == 0);
124
123
  }
125
124
 
126
125
  map->bitmap= buf;
127
126
  map->n_bits= n_bits;
128
127
  create_last_word_mask(map);
129
128
  bitmap_clear_all(map);
130
 
  DBUG_RETURN(0);
 
129
  return(0);
131
130
}
132
131
 
133
132
 
134
133
void bitmap_free(MY_BITMAP *map)
135
134
{
136
 
  DBUG_ENTER("bitmap_free");
137
135
  if (map->bitmap)
138
136
  {
139
137
    if (map->mutex)
141
139
    my_free((char*) map->bitmap, MYF(0));
142
140
    map->bitmap=0;
143
141
  }
144
 
  DBUG_VOID_RETURN;
 
142
  return;
145
143
}
146
144
 
147
145
 
184
182
bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit)
185
183
{
186
184
  bool res;
187
 
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
 
185
  assert(map->bitmap && bitmap_bit < map->n_bits);
188
186
  bitmap_lock(map);
189
187
  res= bitmap_fast_test_and_set(map, bitmap_bit);
190
188
  bitmap_unlock(map);
217
215
bool bitmap_test_and_clear(MY_BITMAP *map, uint bitmap_bit)
218
216
{
219
217
  bool res;
220
 
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
 
218
  assert(map->bitmap && bitmap_bit < map->n_bits);
221
219
  bitmap_lock(map);
222
220
  res= bitmap_fast_test_and_clear(map, bitmap_bit);
223
221
  bitmap_unlock(map);
228
226
uint bitmap_set_next(MY_BITMAP *map)
229
227
{
230
228
  uint bit_found;
231
 
  DBUG_ASSERT(map->bitmap);
 
229
  assert(map->bitmap);
232
230
  if ((bit_found= bitmap_get_first(map)) != MY_BIT_NONE)
233
231
    bitmap_set_bit(map, bit_found);
234
232
  return bit_found;
240
238
  uint prefix_bytes, prefix_bits, d;
241
239
  uchar *m= (uchar *)map->bitmap;
242
240
 
243
 
  DBUG_ASSERT(map->bitmap &&
 
241
  assert(map->bitmap &&
244
242
              (prefix_size <= map->n_bits || prefix_size == (uint) ~0));
245
243
  set_if_smaller(prefix_size, map->n_bits);
246
244
  if ((prefix_bytes= prefix_size / 8))
259
257
  uchar *m= (uchar*)map->bitmap;
260
258
  uchar *end_prefix= m+prefix_size/8;
261
259
  uchar *end;
262
 
  DBUG_ASSERT(m && prefix_size <= map->n_bits);
 
260
  assert(m && prefix_size <= map->n_bits);
263
261
  end= m+no_bytes_in_map(map);
264
262
 
265
263
  while (m < end_prefix)
311
309
{
312
310
  my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
313
311
 
314
 
  DBUG_ASSERT(map1->bitmap && map2->bitmap &&
 
312
  assert(map1->bitmap && map2->bitmap &&
315
313
              map1->n_bits==map2->n_bits);
316
314
 
317
315
  end= map1->last_word_ptr;
331
329
{
332
330
  my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
333
331
 
334
 
  DBUG_ASSERT(map1->bitmap && map2->bitmap &&
 
332
  assert(map1->bitmap && map2->bitmap &&
335
333
              map1->n_bits==map2->n_bits);
336
334
 
337
335
  end= map1->last_word_ptr;
351
349
  my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
352
350
  uint len= no_words_in_map(map), len2 = no_words_in_map(map2);
353
351
 
354
 
  DBUG_ASSERT(map->bitmap && map2->bitmap);
 
352
  assert(map->bitmap && map2->bitmap);
355
353
 
356
354
  end= to+min(len,len2);
357
355
  *map2->last_word_ptr&= ~map2->last_word_mask; /*Clear last bits in map2*/
401
399
void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2)
402
400
{
403
401
  my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
404
 
  DBUG_ASSERT(map->bitmap && map2->bitmap &&
 
402
  assert(map->bitmap && map2->bitmap &&
405
403
              map->n_bits==map2->n_bits);
406
404
 
407
405
  end= map->last_word_ptr;
415
413
{
416
414
  my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
417
415
 
418
 
  DBUG_ASSERT(map->bitmap && map2->bitmap &&
 
416
  assert(map->bitmap && map2->bitmap &&
419
417
              map->n_bits==map2->n_bits);
420
418
  end= map->last_word_ptr;
421
419
 
427
425
void bitmap_xor(MY_BITMAP *map, const MY_BITMAP *map2)
428
426
{
429
427
  my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end= map->last_word_ptr;
430
 
  DBUG_ASSERT(map->bitmap && map2->bitmap &&
 
428
  assert(map->bitmap && map2->bitmap &&
431
429
              map->n_bits==map2->n_bits);
432
430
  while (to <= end)
433
431
    *to++ ^= *from++;
438
436
{
439
437
  my_bitmap_map *to= map->bitmap, *end;
440
438
 
441
 
  DBUG_ASSERT(map->bitmap);
 
439
  assert(map->bitmap);
442
440
  end= map->last_word_ptr;
443
441
 
444
442
  while (to <= end)
452
450
  uchar *end= m + no_bytes_in_map(map);
453
451
  uint res= 0;
454
452
 
455
 
  DBUG_ASSERT(map->bitmap);
 
453
  assert(map->bitmap);
456
454
  *map->last_word_ptr&= ~map->last_word_mask; /*Reset last bits to zero*/
457
455
  while (m < end)
458
456
    res+= my_count_bits_ushort(*m++);
464
462
{
465
463
  my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
466
464
 
467
 
  DBUG_ASSERT(map->bitmap && map2->bitmap &&
 
465
  assert(map->bitmap && map2->bitmap &&
468
466
              map->n_bits==map2->n_bits);
469
467
  end= map->last_word_ptr;
470
468
  while (to <= end)
478
476
  uint i,j,k;
479
477
  my_bitmap_map *data_ptr, *end= map->last_word_ptr;
480
478
 
481
 
  DBUG_ASSERT(map->bitmap);
 
479
  assert(map->bitmap);
482
480
  data_ptr= map->bitmap;
483
481
  *map->last_word_ptr &= ~map->last_word_mask;
484
482
 
496
494
            if (*byte_ptr & (1 << k))
497
495
              return (i*32) + (j*8) + k;
498
496
          }
499
 
          DBUG_ASSERT(0);
 
497
          assert(0);
500
498
        }
501
499
      }
502
 
      DBUG_ASSERT(0);
 
500
      assert(0);
503
501
    }
504
502
  }
505
503
  return MY_BIT_NONE;
512
510
  uint i,j,k;
513
511
  my_bitmap_map *data_ptr, *end= map->last_word_ptr;
514
512
 
515
 
  DBUG_ASSERT(map->bitmap);
 
513
  assert(map->bitmap);
516
514
  data_ptr= map->bitmap;
517
515
  *map->last_word_ptr|= map->last_word_mask;
518
516
 
530
528
            if (!(*byte_ptr & (1 << k)))
531
529
              return (i*32) + (j*8) + k;
532
530
          }
533
 
          DBUG_ASSERT(0);
 
531
          assert(0);
534
532
        }
535
533
      }
536
 
      DBUG_ASSERT(0);
 
534
      assert(0);
537
535
    }
538
536
  }
539
537
  return MY_BIT_NONE;
553
551
void bitmap_lock_clear_bit(MY_BITMAP *map, uint bitmap_bit)
554
552
{
555
553
  bitmap_lock(map);
556
 
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
 
554
  assert(map->bitmap && bitmap_bit < map->n_bits);
557
555
  bitmap_clear_bit(map, bitmap_bit);
558
556
  bitmap_unlock(map);
559
557
}
617
615
bool bitmap_lock_is_set(const MY_BITMAP *map, uint bitmap_bit)
618
616
{
619
617
  bool res;
620
 
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
 
618
  assert(map->bitmap && bitmap_bit < map->n_bits);
621
619
  bitmap_lock((MY_BITMAP *)map);
622
620
  res= bitmap_is_set(map, bitmap_bit);
623
621
  bitmap_unlock((MY_BITMAP *)map);
641
639
{
642
640
  uint res;
643
641
 
644
 
  DBUG_ASSERT(map1->bitmap && map2->bitmap &&
 
642
  assert(map1->bitmap && map2->bitmap &&
645
643
              map1->n_bits==map2->n_bits);
646
644
  bitmap_lock((MY_BITMAP *)map1);
647
645
  bitmap_lock((MY_BITMAP *)map2);
693
691
{
694
692
  uint res;
695
693
  bitmap_lock((MY_BITMAP *)map);
696
 
  DBUG_ASSERT(map->bitmap);
 
694
  assert(map->bitmap);
697
695
  res= bitmap_bits_set(map);
698
696
  bitmap_unlock((MY_BITMAP *)map);
699
697
  return res;
729
727
 
730
728
void bitmap_lock_set_bit(MY_BITMAP *map, uint bitmap_bit)
731
729
{
732
 
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
 
730
  assert(map->bitmap && bitmap_bit < map->n_bits);
733
731
  bitmap_lock(map);
734
732
  bitmap_set_bit(map, bitmap_bit);
735
733
  bitmap_unlock(map);
738
736
 
739
737
void bitmap_lock_flip_bit(MY_BITMAP *map, uint bitmap_bit)
740
738
{
741
 
  DBUG_ASSERT(map->bitmap && bitmap_bit < map->n_bits);
 
739
  assert(map->bitmap && bitmap_bit < map->n_bits);
742
740
  bitmap_lock(map);
743
741
  bitmap_flip_bit(map, bitmap_bit);
744
742
  bitmap_unlock(map);