← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_bitmap.cc

  • Committer: Monty Taylor
  • Date: 2009-05-24 23:54:21 UTC
  • mfrom: (1014.2.12 kill-malloc)
  • mto: This revision was merged to the branch mainline in revision 1039.
  • Revision ID: mordred@inaugust.com-20090524235421-x5vfss90auzbn896
Merged Monty from lp:~mordred/drizzle/kill-malloc

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_bitmap.cc
21
21
 
22
22
    * the internal size is a set of 32 bit words
23
23
    * the number of bits specified in creation can be any number > 0
24
 
    * there are THREAD safe versions of most calls called bitmap_lock_*
25
 
      many of those are not used and not compiled normally but the code
26
 
      already exist for them in an #ifdef:ed part. These can only be used
27
 
      if THREAD was specified in bitmap_init
28
24
 
29
 
  TODO:
30
 
  Make assembler THREAD safe versions of these using test-and-set instructions
31
25
 
32
26
  Original version created by Sergei Golubchik 2001 - 2004.
33
27
  New version written and test program added and some changes to the interface
83
77
}
84
78
 
85
79
 
86
 
static inline void bitmap_lock(MY_BITMAP *map)
87
 
{
88
 
  if (map->mutex)
89
 
    pthread_mutex_lock(map->mutex);
90
 
}
91
 
 
92
 
static inline void bitmap_unlock(MY_BITMAP *map)
93
 
{
94
 
  if (map->mutex)
95
 
    pthread_mutex_unlock(map->mutex);
96
 
}
97
 
 
98
 
 
99
 
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint32_t n_bits, bool thread_safe)
 
80
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint32_t n_bits)
100
81
{
101
82
  if (!buf)
102
83
  {
103
84
    uint32_t size_in_bytes= bitmap_buffer_size(n_bits);
104
 
    uint32_t extra= 0;
105
 
    if (thread_safe)
106
 
    {
107
 
      size_in_bytes= ALIGN_SIZE(size_in_bytes);
108
 
      extra= sizeof(pthread_mutex_t);
109
 
    }
110
 
    map->mutex= 0;
111
 
    if (!(buf= (my_bitmap_map*) malloc(size_in_bytes+extra)))
 
85
    size_in_bytes= ALIGN_SIZE(size_in_bytes);
 
86
    if (!(buf= (my_bitmap_map*) malloc(size_in_bytes)))
112
87
      return(1);
113
 
    if (thread_safe)
114
 
    {
115
 
      map->mutex= (pthread_mutex_t *) ((char*) buf + size_in_bytes);
116
 
      pthread_mutex_init(map->mutex, MY_MUTEX_INIT_FAST);
117
 
    }
118
 
  }
119
 
  else
120
 
  {
121
 
    assert(thread_safe == 0);
122
88
  }
123
89
 
124
90
  map->bitmap= buf;
133
99
{
134
100
  if (map->bitmap)
135
101
  {
136
 
    if (map->mutex)
137
 
      pthread_mutex_destroy(map->mutex);
138
102
    free((char*) map->bitmap);
139
103
    map->bitmap=0;
140
104
  }
143
107
 
144
108
 
145
109
/*
146
 
  test if bit already set and set it if it was not (thread unsafe method)
 
110
  test if bit already set and set it if it was not
147
111
 
148
112
  SYNOPSIS
149
 
    bitmap_fast_test_and_set()
 
113
    bitmap_test_and_set()
150
114
    MAP   bit map struct
151
115
    BIT   bit number
152
116
 
155
119
    !=0  bit was set
156
120
*/
157
121
 
158
 
bool bitmap_fast_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit)
 
122
bool bitmap_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit)
159
123
{
160
124
  unsigned char *value= ((unsigned char*) map->bitmap) + (bitmap_bit / 8);
161
125
  unsigned char bit= 1 << ((bitmap_bit) & 7);
165
129
}
166
130
 
167
131
 
168
 
/*
169
 
  test if bit already set and set it if it was not (thread safe method)
170
 
 
171
 
  SYNOPSIS
172
 
    bitmap_fast_test_and_set()
173
 
    map          bit map struct
174
 
    bitmap_bit   bit number
175
 
 
176
 
  RETURN
177
 
    0    bit was not set
178
 
    !=0  bit was set
179
 
*/
180
 
 
181
 
bool bitmap_test_and_set(MY_BITMAP *map, uint32_t bitmap_bit)
182
 
{
183
 
  bool res;
184
 
  assert(map->bitmap && bitmap_bit < map->n_bits);
185
 
  bitmap_lock(map);
186
 
  res= bitmap_fast_test_and_set(map, bitmap_bit);
187
 
  bitmap_unlock(map);
188
 
  return res;
189
 
}
190
 
 
191
 
/*
192
 
  test if bit already set and clear it if it was set(thread unsafe method)
193
 
 
194
 
  SYNOPSIS
195
 
    bitmap_fast_test_and_set()
 
132
 
 
133
/*
 
134
  test if bit already set and clear it if it was set
 
135
 
 
136
  SYNOPSIS
 
137
    bitmap_test_and_set()
196
138
    MAP   bit map struct
197
139
    BIT   bit number
198
140
 
201
143
    !=0  bit was set
202
144
*/
203
145
 
204
 
bool bitmap_fast_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit)
 
146
bool bitmap_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit)
205
147
{
206
148
  unsigned char *byte= (unsigned char*) map->bitmap + (bitmap_bit / 8);
207
149
  unsigned char bit= 1 << ((bitmap_bit) & 7);
211
153
}
212
154
 
213
155
 
214
 
bool bitmap_test_and_clear(MY_BITMAP *map, uint32_t bitmap_bit)
215
 
{
216
 
  bool res;
217
 
  assert(map->bitmap && bitmap_bit < map->n_bits);
218
 
  bitmap_lock(map);
219
 
  res= bitmap_fast_test_and_clear(map, bitmap_bit);
220
 
  bitmap_unlock(map);
221
 
  return res;
222
 
}
223
 
 
224
156
 
225
157
uint32_t bitmap_set_next(MY_BITMAP *map)
226
158
{
533
465
}
534
466
 
535
467
 
536
 
uint32_t bitmap_lock_set_next(MY_BITMAP *map)
537
 
{
538
 
  uint32_t bit_found;
539
 
  bitmap_lock(map);
540
 
  bit_found= bitmap_set_next(map);
541
 
  bitmap_unlock(map);
542
 
  return bit_found;
543
 
}
544
 
 
545
 
 
546
 
void bitmap_lock_clear_bit(MY_BITMAP *map, uint32_t bitmap_bit)
547
 
{
548
 
  bitmap_lock(map);
549
 
  assert(map->bitmap && bitmap_bit < map->n_bits);
550
 
  bitmap_clear_bit(map, bitmap_bit);
551
 
  bitmap_unlock(map);
552
 
}
553
 
 
554
 
 
555
 
#ifdef NOT_USED
556
 
bool bitmap_lock_is_prefix(const MY_BITMAP *map, uint32_t prefix_size)
557
 
{
558
 
  bool res;
559
 
  bitmap_lock((MY_BITMAP *)map);
560
 
  res= bitmap_is_prefix(map, prefix_size);
561
 
  bitmap_unlock((MY_BITMAP *)map);
562
 
  return res;
563
 
}
564
 
 
565
 
 
566
 
void bitmap_lock_set_all(MY_BITMAP *map)
567
 
{
568
 
  bitmap_lock(map);
569
 
  bitmap_set_all(map);
570
 
  bitmap_unlock(map);
571
 
}
572
 
 
573
 
 
574
 
void bitmap_lock_clear_all(MY_BITMAP *map)
575
 
{
576
 
  bitmap_lock(map);
577
 
  bitmap_clear_all(map);
578
 
  bitmap_unlock(map);
579
 
}
580
 
 
581
 
 
582
 
void bitmap_lock_set_prefix(MY_BITMAP *map, uint32_t prefix_size)
583
 
{
584
 
  bitmap_lock(map);
585
 
  bitmap_set_prefix(map, prefix_size);
586
 
  bitmap_unlock(map);
587
 
}
588
 
 
589
 
 
590
 
bool bitmap_lock_is_clear_all(const MY_BITMAP *map)
591
 
{
592
 
  uint32_t res;
593
 
  bitmap_lock((MY_BITMAP *)map);
594
 
  res= bitmap_is_clear_all(map);
595
 
  bitmap_unlock((MY_BITMAP *)map);
596
 
  return res;
597
 
}
598
 
 
599
 
 
600
 
bool bitmap_lock_is_set_all(const MY_BITMAP *map)
601
 
{
602
 
  uint32_t res;
603
 
  bitmap_lock((MY_BITMAP *)map);
604
 
  res= bitmap_is_set_all(map);
605
 
  bitmap_unlock((MY_BITMAP *)map);
606
 
  return res;
607
 
}
608
 
 
609
 
 
610
 
bool bitmap_lock_is_set(const MY_BITMAP *map, uint32_t bitmap_bit)
611
 
{
612
 
  bool res;
613
 
  assert(map->bitmap && bitmap_bit < map->n_bits);
614
 
  bitmap_lock((MY_BITMAP *)map);
615
 
  res= bitmap_is_set(map, bitmap_bit);
616
 
  bitmap_unlock((MY_BITMAP *)map);
617
 
  return res;
618
 
}
619
 
 
620
 
 
621
 
bool bitmap_lock_is_subset(const MY_BITMAP *map1, const MY_BITMAP *map2)
622
 
{
623
 
  uint32_t res;
624
 
  bitmap_lock((MY_BITMAP *)map1);
625
 
  bitmap_lock((MY_BITMAP *)map2);
626
 
  res= bitmap_is_subset(map1, map2);
627
 
  bitmap_unlock((MY_BITMAP *)map2);
628
 
  bitmap_unlock((MY_BITMAP *)map1);
629
 
  return res;
630
 
}
631
 
 
632
 
 
633
 
bool bitmap_lock_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
634
 
{
635
 
  uint32_t res;
636
 
 
637
 
  assert(map1->bitmap && map2->bitmap &&
638
 
              map1->n_bits==map2->n_bits);
639
 
  bitmap_lock((MY_BITMAP *)map1);
640
 
  bitmap_lock((MY_BITMAP *)map2);
641
 
  res= bitmap_cmp(map1, map2);
642
 
  bitmap_unlock((MY_BITMAP *)map2);
643
 
  bitmap_unlock((MY_BITMAP *)map1);
644
 
  return res;
645
 
}
646
 
 
647
 
 
648
 
void bitmap_lock_intersect(MY_BITMAP *map, const MY_BITMAP *map2)
649
 
{
650
 
  bitmap_lock(map);
651
 
  bitmap_lock((MY_BITMAP *)map2);
652
 
  bitmap_intersect(map, map2);
653
 
  bitmap_unlock((MY_BITMAP *)map2);
654
 
  bitmap_unlock(map);
655
 
}
656
 
 
657
 
 
658
 
void bitmap_lock_subtract(MY_BITMAP *map, const MY_BITMAP *map2)
659
 
{
660
 
  bitmap_lock(map);
661
 
  bitmap_lock((MY_BITMAP *)map2);
662
 
  bitmap_subtract(map, map2);
663
 
  bitmap_unlock((MY_BITMAP *)map2);
664
 
  bitmap_unlock(map);
665
 
}
666
 
 
667
 
 
668
 
void bitmap_lock_union(MY_BITMAP *map, const MY_BITMAP *map2)
669
 
{
670
 
  bitmap_lock(map);
671
 
  bitmap_lock((MY_BITMAP *)map2);
672
 
  bitmap_union(map, map2);
673
 
  bitmap_unlock((MY_BITMAP *)map2);
674
 
  bitmap_unlock(map);
675
 
}
676
 
 
677
 
 
678
 
/*
679
 
  SYNOPSIS
680
 
    bitmap_bits_set()
681
 
      map
682
 
  RETURN
683
 
    Number of set bits in the bitmap.
684
 
*/
685
 
uint32_t bitmap_lock_bits_set(const MY_BITMAP *map)
686
 
{
687
 
  uint32_t res;
688
 
  bitmap_lock((MY_BITMAP *)map);
689
 
  assert(map->bitmap);
690
 
  res= bitmap_bits_set(map);
691
 
  bitmap_unlock((MY_BITMAP *)map);
692
 
  return res;
693
 
}
694
 
 
695
 
 
696
 
/*
697
 
  SYNOPSIS
698
 
    bitmap_get_first()
699
 
      map
700
 
  RETURN
701
 
    Number of first unset bit in the bitmap or MY_BIT_NONE if all bits are set.
702
 
*/
703
 
uint32_t bitmap_lock_get_first(const MY_BITMAP *map)
704
 
{
705
 
  uint32_t res;
706
 
  bitmap_lock((MY_BITMAP*)map);
707
 
  res= bitmap_get_first(map);
708
 
  bitmap_unlock((MY_BITMAP*)map);
709
 
  return res;
710
 
}
711
 
 
712
 
 
713
 
uint32_t bitmap_lock_get_first_set(const MY_BITMAP *map)
714
 
{
715
 
  uint32_t res;
716
 
  bitmap_lock((MY_BITMAP*)map);
717
 
  res= bitmap_get_first_set(map);
718
 
  bitmap_unlock((MY_BITMAP*)map);
719
 
  return res;
720
 
}
721
 
 
722
 
 
723
 
void bitmap_lock_set_bit(MY_BITMAP *map, uint32_t bitmap_bit)
724
 
{
725
 
  assert(map->bitmap && bitmap_bit < map->n_bits);
726
 
  bitmap_lock(map);
727
 
  bitmap_set_bit(map, bitmap_bit);
728
 
  bitmap_unlock(map);
729
 
}
730
 
 
731
 
 
732
 
void bitmap_lock_flip_bit(MY_BITMAP *map, uint32_t bitmap_bit)
733
 
{
734
 
  assert(map->bitmap && bitmap_bit < map->n_bits);
735
 
  bitmap_lock(map);
736
 
  bitmap_flip_bit(map, bitmap_bit);
737
 
  bitmap_unlock(map);
738
 
}
739
 
#endif
740
468
#ifdef MAIN
741
469
 
742
470
uint32_t get_rand_bit(uint32_t bitsize)
845
573
  MY_BITMAP *map2= &map2_obj, *map3= &map3_obj;
846
574
  my_bitmap_map map2buf[1024];
847
575
  my_bitmap_map map3buf[1024];
848
 
  bitmap_init(&map2_obj, map2buf, bitsize, false);
849
 
  bitmap_init(&map3_obj, map3buf, bitsize, false);
 
576
  bitmap_init(&map2_obj, map2buf, bitsize);
 
577
  bitmap_init(&map3_obj, map3buf, bitsize);
850
578
  bitmap_clear_all(map2);
851
579
  bitmap_clear_all(map3);
852
580
  for (i=0; i < no_loops; i++)
1052
780
{
1053
781
  MY_BITMAP map;
1054
782
  my_bitmap_map buf[1024];
1055
 
  if (bitmap_init(&map, buf, bitsize, false))
 
783
  if (bitmap_init(&map, buf, bitsize))
1056
784
  {
1057
785
    printf("init error for bitsize %d", bitsize);
1058
786
    goto error;