← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/uniques.cc

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/uniques.cc
57
57
}
58
58
 
59
59
Unique::Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
60
 
               uint size_arg, uint64_t max_in_memory_size_arg)
 
60
               uint32_t size_arg, uint64_t max_in_memory_size_arg)
61
61
  :max_in_memory_size(max_in_memory_size_arg), size(size_arg), elements(0)
62
62
{
63
63
  my_b_clear(&file);
126
126
      total_buf_elems* log2(n_buffers) / TIME_FOR_COMPARE_ROWID;
127
127
*/
128
128
 
129
 
static double get_merge_buffers_cost(uint *buff_elems __attribute__((unused)),
130
 
                                     uint elem_size,
131
 
                                     uint *first, uint *last)
 
129
static double get_merge_buffers_cost(uint32_t *buff_elems __attribute__((unused)),
 
130
                                     uint32_t elem_size,
 
131
                                     uint32_t *first, uint32_t *last)
132
132
{
133
 
  uint total_buf_elems= 0;
134
 
  for (uint *pbuf= first; pbuf <= last; pbuf++)
 
133
  uint32_t total_buf_elems= 0;
 
134
  for (uint32_t *pbuf= first; pbuf <= last; pbuf++)
135
135
    total_buf_elems+= *pbuf;
136
136
  *last= total_buf_elems;
137
137
 
170
170
    Cost of merge in disk seeks.
171
171
*/
172
172
 
173
 
static double get_merge_many_buffs_cost(uint *buffer,
174
 
                                        uint maxbuffer, uint max_n_elems,
175
 
                                        uint last_n_elems, int elem_size)
 
173
static double get_merge_many_buffs_cost(uint32_t *buffer,
 
174
                                        uint32_t maxbuffer, uint32_t max_n_elems,
 
175
                                        uint32_t last_n_elems, int elem_size)
176
176
{
177
177
  register int i;
178
178
  double total_cost= 0.0;
179
 
  uint *buff_elems= buffer; /* #s of elements in each of merged sequences */
 
179
  uint32_t *buff_elems= buffer; /* #s of elements in each of merged sequences */
180
180
 
181
181
  /*
182
182
    Set initial state: first maxbuffer sequences contain max_n_elems elements
194
194
  {
195
195
    while (maxbuffer >= MERGEBUFF2)
196
196
    {
197
 
      uint lastbuff= 0;
 
197
      uint32_t lastbuff= 0;
198
198
      for (i = 0; i <= (int) maxbuffer - MERGEBUFF*3/2; i += MERGEBUFF)
199
199
      {
200
200
        total_cost+=get_merge_buffers_cost(buff_elems, elem_size,
263
263
      these will be random seeks.
264
264
*/
265
265
 
266
 
double Unique::get_use_cost(uint *buffer, uint nkeys, uint key_size,
 
266
double Unique::get_use_cost(uint32_t *buffer, uint32_t nkeys, uint32_t key_size,
267
267
                            uint64_t max_in_memory_size)
268
268
{
269
269
  ulong max_elements_in_tree;
420
420
*/
421
421
 
422
422
static bool merge_walk(unsigned char *merge_buffer, ulong merge_buffer_size,
423
 
                       uint key_length, BUFFPEK *begin, BUFFPEK *end,
 
423
                       uint32_t key_length, BUFFPEK *begin, BUFFPEK *end,
424
424
                       tree_walk_action walk_action, void *walk_action_arg,
425
425
                       qsort_cmp2 compare, void *compare_arg,
426
426
                       IO_CACHE *file)
435
435
  /* we need space for one key when a piece of merge buffer is re-read */
436
436
  merge_buffer_size-= key_length;
437
437
  unsigned char *save_key_buff= merge_buffer + merge_buffer_size;
438
 
  uint max_key_count_per_piece= (uint) (merge_buffer_size/(end-begin) /
 
438
  uint32_t max_key_count_per_piece= (uint) (merge_buffer_size/(end-begin) /
439
439
                                        key_length);
440
440
  /* if piece_size is aligned reuse_freed_buffer will always hit */
441
 
  uint piece_size= max_key_count_per_piece * key_length;
442
 
  uint bytes_read;               /* to hold return value of read_to_buffer */
 
441
  uint32_t piece_size= max_key_count_per_piece * key_length;
 
442
  uint32_t bytes_read;               /* to hold return value of read_to_buffer */
443
443
  BUFFPEK *top;
444
444
  int res= 1;
445
445
  /*
601
601
 
602
602
  IO_CACHE *outfile=table->sort.io_cache;
603
603
  BUFFPEK *file_ptr= (BUFFPEK*) file_ptrs.buffer;
604
 
  uint maxbuffer= file_ptrs.elements - 1;
 
604
  uint32_t maxbuffer= file_ptrs.elements - 1;
605
605
  unsigned char *sort_buffer;
606
606
  my_off_t save_pos;
607
607
  bool error=1;