← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mf_keycache.c

Merged in Jay's tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mf_keycache.c
1289
1289
 
1290
1290
  NOTES.
1291
1291
    Every linking to the LRU ring decrements by one a special block
1292
 
    counter (if it's positive). If the at_end parameter is TRUE the block is
 
1292
    counter (if it's positive). If the at_end parameter is true the block is
1293
1293
    added either at the end of warm sub-chain or at the end of hot sub-chain.
1294
1294
    It is added to the hot subchain if its counter is zero and number of
1295
1295
    blocks in warm sub-chain is not less than some low limit (determined by
1296
1296
    the division_limit parameter). Otherwise the block is added to the warm
1297
 
    sub-chain. If the at_end parameter is FALSE the block is always added
 
1297
    sub-chain. If the at_end parameter is false the block is always added
1298
1298
    at beginning of the warm sub-chain.
1299
1299
    Thus a warm block can be promoted to the hot sub-chain when its counter
1300
1300
    becomes zero for the first time.
2222
2222
              and hash_link refer to each other. Hence we need to assign
2223
2223
              the hash_link first, but then we would not know if it was
2224
2224
              linked before. Hence we would not know if to unlink it. So
2225
 
              unlink it here and call link_to_file_list(..., FALSE).
 
2225
              unlink it here and call link_to_file_list(..., false).
2226
2226
            */
2227
2227
            unlink_changed(block);
2228
2228
          }
2459
2459
    The function ensures that a block of data of size length from file
2460
2460
    positioned at filepos is in the buffers for some key cache blocks.
2461
2461
    Then the function either copies the data into the buffer buff, or,
2462
 
    if return_buffer is TRUE, it just returns the pointer to the key cache
 
2462
    if return_buffer is true, it just returns the pointer to the key cache
2463
2463
    buffer with the data.
2464
2464
    Filepos must be a multiple of 'block_length', but it doesn't
2465
2465
    have to be a multiple of key_cache_block_size;
2471
2471
                      uint block_length __attribute__((unused)),
2472
2472
                      int return_buffer __attribute__((unused)))
2473
2473
{
2474
 
  my_bool locked_and_incremented= FALSE;
 
2474
  my_bool locked_and_incremented= false;
2475
2475
  int error=0;
2476
2476
  uchar *start= buff;
2477
2477
  DBUG_ENTER("key_cache_read");
2512
2512
      wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
2513
2513
    /* Register the I/O for the next resize. */
2514
2514
    inc_counter_for_resize_op(keycache);
2515
 
    locked_and_incremented= TRUE;
 
2515
    locked_and_incremented= true;
2516
2516
    /* Requested data may not always be aligned to cache blocks. */
2517
2517
    offset= (uint) (filepos % keycache->key_cache_block_size);
2518
2518
    /* Read data in key_cache_block_size increments */
2679
2679
    uint read_length;
2680
2680
    uint offset;
2681
2681
    int page_st;
2682
 
    my_bool locked_and_incremented= FALSE;
 
2682
    my_bool locked_and_incremented= false;
2683
2683
 
2684
2684
    /*
2685
2685
      When the keycache is once initialized, we use the cache_lock to
2696
2696
        goto no_key_cache;
2697
2697
    /* Register the pseudo I/O for the next resize. */
2698
2698
    inc_counter_for_resize_op(keycache);
2699
 
    locked_and_incremented= TRUE;
 
2699
    locked_and_incremented= true;
2700
2700
    /* Loaded data may not always be aligned to cache blocks. */
2701
2701
    offset= (uint) (filepos % keycache->key_cache_block_size);
2702
2702
    /* Load data in key_cache_block_size increments. */
2741
2741
            hash_link). So we cannot call remove_reader() on the block.
2742
2742
            And we cannot access the hash_link directly here. We need to
2743
2743
            wait until the assignment is complete. read_block() executes
2744
 
            the correct wait when called with primary == FALSE.
 
2744
            the correct wait when called with primary == false.
2745
2745
 
2746
2746
            Or
2747
2747
 
2898
2898
    The function copies the data of size length from buff into buffers
2899
2899
    for key cache blocks that are  assigned to contain the portion of
2900
2900
    the file starting with position filepos.
2901
 
    It ensures that this data is flushed to the file if dont_write is FALSE.
 
2901
    It ensures that this data is flushed to the file if dont_write is false.
2902
2902
    Filepos must be a multiple of 'block_length', but it doesn't
2903
2903
    have to be a multiple of key_cache_block_size;
2904
2904
 
2905
 
    dont_write is always TRUE in the server (info->lock_type is never F_UNLCK).
 
2905
    dont_write is always true in the server (info->lock_type is never F_UNLCK).
2906
2906
*/
2907
2907
 
2908
2908
int key_cache_write(KEY_CACHE *keycache,
2911
2911
                    uint block_length  __attribute__((unused)),
2912
2912
                    int dont_write)
2913
2913
{
2914
 
  my_bool locked_and_incremented= FALSE;
 
2914
  my_bool locked_and_incremented= false;
2915
2915
  int error=0;
2916
2916
  DBUG_ENTER("key_cache_write");
2917
2917
  DBUG_PRINT("enter",
2971
2971
      wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
2972
2972
    /* Register the I/O for the next resize. */
2973
2973
    inc_counter_for_resize_op(keycache);
2974
 
    locked_and_incremented= TRUE;
 
2974
    locked_and_incremented= true;
2975
2975
    /* Requested data may not always be aligned to cache blocks. */
2976
2976
    offset= (uint) (filepos % keycache->key_cache_block_size);
2977
2977
    /* Write data in key_cache_block_size increments. */