maria-developers team mailing list archive
-
maria-developers team
-
Mailing list archive
-
Message #02851
Re: bzr commit into Mariadb 5.2, with Maria 2.0:maria/5.2 branch (igor:2742) WL#85
Monty,
I addressed almost all problems you pointed to in your review.
The only issue that I did not cover concerns requirement to put
select.test in separate suite. People would be screaming if I did it,
because this is one of the most touchable tests.
See my new patch a the very end of this post.
Michael Widenius wrote:
> Hi!
>
>>>>>> "Igor" == Igor Babaev <igor@xxxxxxxxxxxx> writes:
>
> Igor> Please review this patch that is based on the contribution patch
> Igor> attached to WL#86.
>
> <cut>
>
> First some things we discussed in Iceland:
>
> Functions with starts with s_.... should be changed to simple_....
Done!
>
> Move select.test to suite/select and run it with different keycache
> parameters (to not repeat select.result)
>
> Igor> 2742 Igor Babaev 2010-02-16
> Igor> WL#86: Partitioned key cache for MyISAM.
> Igor> This is the base patch for the task.
>
> Igor> === modified file 'mysys/mf_keycache.c'
>
> Igor> +#define KEYCACHE_BASE_EXPR(f, pos)
> Igor> \
> Igor> + ((ulong) ((pos) / keycache->key_cache_block_size) + (ulong) (f))
> Igor> #define KEYCACHE_HASH(f, pos)
> Igor> \
> Igor> -(((ulong) ((pos) / keycache->key_cache_block_size) +
> Igor> \
> Igor> - (ulong) (f)) &
> Igor> (keycache->hash_entries-1))
> Igor> + ((KEYCACHE_BASE_EXPR(f, pos) / keycache->hash_factor) &
> Igor> \
> Igor> + (keycache->hash_entries-1))
> Igor> #define FILE_HASH(f) ((uint) (f) & (CHANGED_BLOCKS_HASH-1))
>
> As all the divisiors are powers of two, would it be more efficent to store
> the shift factor in 'keycache' and do shifts instead of / ?
> (I assume that even on modern CPU:s shift is much faster then /)
keycache->hash_factor=number of partitions in the key cache may be any
number between 1 and 64.
>
> Igor> +static
> Igor> +void s_finish_resize_key_cache(void *keycache_cb,
> Igor> + my_bool with_resize_queue,
> Igor> + my_bool acquire_lock)
> Igor> +{
> Igor> + S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
> Igor> + DBUG_ENTER("s_finish_resize_key_cache");
> Igor> +
> Igor> + if (acquire_lock)
> Igor> + keycache_pthread_mutex_lock(&keycache->cache_lock);
> Igor> +
>
> Add after this:
>
> safe_mutex_assert_owner((&keycache->cache_lock);
Added
>
> <cut>
>
> Igor> +static
> Igor> +int s_resize_key_cache(void *keycache_cb, uint key_cache_block_size,
> Igor> + size_t use_mem, uint division_limit,
> Igor> + uint age_threshold)
> Igor> +{
> Igor> + S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
>
> It may be better if this function would take S_KEY_CACHE_CB as a parameter.
> This can easily be done by doing a cast when storing the function pointer
> into the st_key_cache_funcs array.
>
> This way all casts are in one place and all real functions can avoid
> casts. The same thing applies for all other interface functions.
> This mainly makes the real code look a bit nicer
Done.
>
> Igor> + int blocks= 0;
> Igor> + DBUG_ENTER("s_resize_key_cache");
> Igor> +
> Igor> + if (!keycache->key_cache_inited)
> Igor> + DBUG_RETURN(keycache->disk_blocks);
>
> Shouldn't we return 0 if cache was not initied ?
> (if not inited, disk_blocks may contain random data)
Corrected
>
> Igor> @@ -670,7 +894,7 @@ finish:
> Igor> /*
> Igor> Increment counter blocking resize key cache operation
> Igor> */
> Igor> -static inline void inc_counter_for_resize_op(KEY_CACHE *keycache)
> Igor> +static inline void inc_counter_for_resize_op(S_KEY_CACHE_CB *keycache)
> Igor> {
> Igor> keycache->cnt_for_resize_op++;
> Igor> }
> Igor> @@ -680,35 +904,49 @@ static inline void inc_counter_for_resiz
> Igor> Decrement counter blocking resize key cache operation;
> Igor> Signal the operation to proceed when counter becomes equal zero
> Igor> */
> Igor> -static inline void dec_counter_for_resize_op(KEY_CACHE *keycache)
> Igor> +static inline void dec_counter_for_resize_op(S_KEY_CACHE_CB *keycache)
>
> Many changes are just like the one above.
>
> Wouldn't it been easier to keep KEY_CACHE as the orignal value
> and add KEY_CACHE_MULTI as the new one ?
>
> (This would make future merger with the MySQL code easier too)
It won't make the future merges really easier.
Besides, it's not a good practice to change the names of the interface
objects.
>
>
> <cut>
>
> Igor> +
> Igor> +/*
> Igor> + Get statistics for a simple key cache
> Igor> +
> Igor> + SYNOPSIS
> Igor> + get_key_cache_statistics()
> Igor> + keycache_cb pointer to the control block of a simple key cache
> Igor> + partition_no partition number (not used)
> Igor> + key_cache_stats OUT pointer to the structure for the returned
> Igor> statistics
> Igor> +
> Igor> + DESCRIPTION
> Igor> + This function is the implementation of the get_key_cache_statistics
> Igor> + interface function that is employed by simple (non-partitioned) key
> Igor> caches.
> Igor> + The function considers the parameter keycache_cb as a pointer to the
> Igor> + control block structure of the type S_KEY_CACHE_CB for a simple key
> Igor> cache.
> Igor> + This function returns the statistical data for the key cache.
> Igor> + The parameter partition_no is not used by this function.
> Igor> +
> Igor> + RETURN
> Igor> + none
> Igor> +
> Igor> +*/
>
> A small thing, but better point them out (to ensure we agree on the
> coding style):
>
> Remove the extra empty line after 'none'.
Done.
>
> The current style is:
>
> No empty lines at end of comments
> One empty line between function comment and function.
> Two empty lines before function comment (to separate it from previous function)
>
> Igor> +
> Igor> +static
> Igor> +void s_get_key_cache_statistics(void *keycache_cb,
> Igor> + uint partition_no __attribute__((unused)),
> Igor> + KEY_CACHE_STATISTICS *key_cache_stats)
> Igor> +{
> Igor> + S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
> Igor> + DBUG_ENTER("s_get_key_cache_statistics");
> Igor> +
> Igor> + key_cache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
> Igor> + key_cache_stats->block_size= (longlong) keycache->key_cache_block_size;
> Igor> + key_cache_stats->blocks_used= keycache->blocks_used;
> Igor> + key_cache_stats->blocks_unused= keycache->blocks_unused;
> Igor> + key_cache_stats->blocks_changed= keycache->global_blocks_changed;
> Igor> + key_cache_stats->read_requests= keycache->global_cache_r_requests;
> Igor> + key_cache_stats->reads= keycache->global_cache_read;
> Igor> + key_cache_stats->write_requests= keycache->global_cache_w_requests;
> Igor> + key_cache_stats->writes= keycache->global_cache_write;
> Igor> + DBUG_VOID_RETURN;
> Igor> +}
>
> Please ensure that all keycache variables are of the same style.
> Use either keycache or key_cache everywhere!
> (See above for confusing example)
>
Done
>
> Igor> +
> Igor> +
> Igor> +static size_t s_key_cache_stat_var_offsets[]=
> Igor> +{
> Igor> + offsetof(S_KEY_CACHE_CB, blocks_used),
> Igor> + offsetof(S_KEY_CACHE_CB, blocks_unused),
> Igor> + offsetof(S_KEY_CACHE_CB, global_blocks_changed),
> Igor> + offsetof(S_KEY_CACHE_CB, global_cache_w_requests),
> Igor> + offsetof(S_KEY_CACHE_CB, global_cache_write),
> Igor> + offsetof(S_KEY_CACHE_CB, global_cache_r_requests),
> Igor> + offsetof(S_KEY_CACHE_CB, global_cache_read)
> Igor> +};
> Igor> +
> Igor> +
> Igor> +/*
> Igor> + Get the value of a statistical variable for a simple key cache
> Igor> +
> Igor> + SYNOPSIS
> Igor> + s_get_key_cache_stat_value()
> Igor> + keycache_cb pointer to the control block of a simple key cache
> Igor> + var_no the ordered number of a statistical variable
> Igor> +
> Igor> + DESCRIPTION
> Igor> + This function is the implementation of the s_get_key_cache_stat_value
> Igor> + interface function that is employed by simple (non-partitioned) key
> Igor> caches.
> Igor> + The function considers the parameter keycache_cb as a pointer to the
> Igor> + control block structure of the type S_KEY_CACHE_CB for a simple key
> Igor> cache.
> Igor> + This function returns the value of the statistical variable var_no
> Igor> + for this key cache. The variables are numbered starting from 0 to 6.
> Igor> +
> Igor> + RETURN
> Igor> + The value of the specified statistical variable
> Igor> +
> Igor> +*/
> Igor> +
> Igor> +static
> Igor> +ulonglong s_get_key_cache_stat_value(void *keycache_cb, uint var_no)
> Igor> +{
> Igor> + S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
> Igor> + size_t var_ofs= s_key_cache_stat_var_offsets[var_no];
> Igor> + ulonglong res= 0;
> Igor> + DBUG_ENTER("s_get_key_cache_stat_value");
> Igor> +
> Igor> + if (var_no < NO_LONG_KEY_CACHE_STAT_VARIABLES)
>
> Change the above to a define that is in the header file and add a
> comment to where s_key_cache_stat_var_offsets are defined).
> (Otherwise someone will surely break things sooner or later!)
Done.
>
> Igor> + res= (ulonglong) (*(long *) ((char *) keycache + var_ofs));
> Igor> + else
> Igor> + res= *(ulonglong *) ((char *) keycache + var_ofs);
> Igor> +
> Igor> + DBUG_RETURN(res);
> Igor> +}
> Igor> +
> Igor> +
> Igor> +/*
> Igor> + The array of pointer to the key cache interface functions used for simple
> Igor> + key caches. Any simple key cache objects including those incorporated
> Igor> into
> Igor> + partitioned keys caches exploit this array.
> Igor> +
> Igor> + The current implementation of these functions allows to call them from
> Igor> + the MySQL server code directly. We don't do it though.
> Igor> +*/
> Igor> +
> Igor> +static KEY_CACHE_FUNCS s_key_cache_funcs =
> Igor> +{
> Igor> + s_init_key_cache,
> Igor> + s_resize_key_cache,
> Igor> + s_change_key_cache_param,
> Igor> + s_key_cache_read,
> Igor> + s_key_cache_insert,
> Igor> + s_key_cache_write,
> Igor> + s_flush_key_blocks,
> Igor> + s_reset_key_cache_counters,
> Igor> + s_end_key_cache,
> Igor> + s_get_key_cache_statistics,
> Igor> + s_get_key_cache_stat_value
> Igor> +};
>
> Here is where you can add casts so that you don't need them in the functions.
>
> <cut>
>
> Igor> +/* Control block for a partitioned key cache */
> Igor> +
> Igor> +typedef struct st_p_key_cache_cb
> Igor> +{
> Igor> + my_bool key_cache_inited; /*<=> control block is allocated
> Igor> */
> Igor> + S_KEY_CACHE_CB **partition_array; /* array of the key cache
> Igor> partitions */
> Igor> + uint partitions; /* number of partitions in the key
> Igor> cache */
> Igor> + size_t key_cache_mem_size; /* specified size of the cache memory
> Igor> */
> Igor> + uint key_cache_block_size; /* size of the page buffer of a cache
> Igor> block */
> Igor> +} P_KEY_CACHE_CB;
>
> Please move the uint values after each other (gives better alignment)
Done
>
> Igor> +
> Igor> +static
> Igor> +void p_end_key_cache(void *keycache_cb, my_bool cleanup);
>
> Move the above declaration to start of file (together with all other
> static declarations)
I would rather keep it in the module/part for partitioned key cache.
Only very old compilers complain about such parctice.
>
> <cut>
>
> Igor> +
> Igor> +static
> Igor> +S_KEY_CACHE_CB *get_key_cache_partition_for_write(P_KEY_CACHE_CB
> Igor> *keycache,
> Igor> + File file, my_off_t
> Igor> filepos,
> Igor> + ulonglong*
> Igor> dirty_part_map)
>
> Put a new line after 'S_KEY_CACHE_CB *'; this makes the line more readable.
Done
>
>
> Igor> + If keycache->key_cache_inited != 0 then we assume that the memory for
> Igor> + the array of partitions has been already allocated.
> Igor> +
> Igor> + It's assumed that no two threads call this function simultaneously
> Igor> + referring to the same key cache handle.
> Igor> +*/
>
> I don't think we can assume that any memory is initialized to 0.
> Better to have an argument that tells if the memory is already
> initialized or not.
Don't follow you here. What exactly do you mean?
>
>
> Igor> +
> Igor> +static
> Igor> +int p_init_key_cache(void *keycache_cb, uint key_cache_block_size,
> Igor> + size_t use_mem, uint division_limit,
> Igor> + uint age_threshold)
> Igor> +{
> Igor> + int i;
> Igor> + size_t mem_per_cache;
> Igor> + int cnt;
> Igor> + S_KEY_CACHE_CB *partition;
> Igor> + S_KEY_CACHE_CB **partition_ptr;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint partitions= keycache->partitions;
>
> It would be better if partitions would be part of the init call, as
> otherwise the caller need to initialize the keycache->partitions
> before the call, which is more cumbersome.
But otherwise I would have to add a new parameter to interface
init_key_cache function. If you insist I could do it.
>
> Igor> + int blocks= -1;
> Igor> + DBUG_ENTER("p_init_key_cache");
> Igor> +
> Igor> + keycache->key_cache_block_size = key_cache_block_size;
> Igor> +
> Igor> + if (keycache->key_cache_inited)
>
> Remove above test; We can't make a decisions bases on a struct that we are
> about to initialize.
No, we are initializing only the control block structure for the key cache.
>
> Igor> + partition_ptr= keycache->partition_array;
> Igor> + else
> Igor> + {
> Igor> + if(!(partition_ptr=
> Igor> + (S_KEY_CACHE_CB **) my_malloc(sizeof(S_KEY_CACHE_CB *) * partitions,
> Igor> + MYF(0))))
> Igor> + DBUG_RETURN(blocks);
>
> MYF(0) -> MYF(MY_WME) (So that we get a proper error message)
> Please return -1 instead of blocks (easier to understand).
Done
>
> Igor> + keycache->partition_array= partition_ptr;
> Igor> + }
> Igor> +
> Igor> + mem_per_cache = use_mem / partitions;
> Igor> +
> Igor> + for (i= 0; i < (int) partitions; i++)
> Igor> + {
> Igor> + my_bool key_cache_inited= keycache->key_cache_inited;
> Igor> + if (key_cache_inited)
> Igor> + partition= *partition_ptr;
> Igor> + else
> Igor> + {
> Igor> + if (!(partition= (S_KEY_CACHE_CB *)
> Igor> my_malloc(sizeof(S_KEY_CACHE_CB),
> Igor> + MYF(0))))
> Igor> + continue;
>
> If we fail, shouldn't we abort ?
> After all, we can't assume we will be able to allocate any other
> partition after this one.
> Here we should probably use MYF(MY_WME) too.
>
> Igor> + partition->key_cache_inited= 0;
> Igor> + }
> Igor> +
> Igor> + if ((cnt= s_init_key_cache(partition,
> Igor> + key_cache_block_size, mem_per_cache,
> Igor> + division_limit, age_threshold)) <= 0)
> Igor> + {
> Igor> + s_end_key_cache(partition, 1);
> Igor> + my_free((uchar *) partition, MYF(0));
>
> my_free() don't need a cast.
Corrected.
>
> Igor> + partition= 0;
> Igor> + if (key_cache_inited)
> Igor> + {
> Igor> + memmove(partition_ptr, partition_ptr+1,
> Igor> + sizeof(partition_ptr)*(partitions-i-1));
> Igor> + }
> Igor> + if (i == 0)
> Igor> + {
> Igor> + i--;
> Igor> + partitions--;
> Igor> + if (partitions)
> Igor> + mem_per_cache = use_mem / partitions;
> Igor> + }
> Igor> + continue;
> Igor> + }
>
> I don't like the above code to try to recalculate the memory size:
>
> - You uncrease the size of the next partitions, but the total will
> not be use_mem anyway, so it's a bit pointless.
> - It will make the caches of different sizes, which is probably not
> what the user wants anyway.
>
> I think it would be better to be able to just fail if we can't
> allocate all memory.
> - Less confusing for the user
> - If we get a memory error here, something is probably very wrong anyway so
> it's better to release memory and abort.
> - Simpler code
Ok, to have partitions of different size is not a idea. I changed the
code to have all allocated partitions of the same size. Still I allow to
fail with memory allocation for some partitions (usually they are the
last ones). Why not ?
>
> Igor> + if (blocks < 0)
> Igor> + blocks= 0;
>
> Whey the special logic with the first loop ?
> Please add a commment or just set block to 0 instead of -1 and
> set block to -1 on error / at abort
Corrected.
>
> <cut>
>
> Igor> +static
> Igor> +int p_resize_key_cache(void *keycache_cb, uint key_cache_block_size,
> Igor> + size_t use_mem, uint division_limit,
> Igor> + uint age_threshold)
> Igor> +{
> Igor> + uint i;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint partitions= keycache->partitions;
> Igor> + my_bool cleanup= use_mem == 0;
> Igor> + int blocks= -1;
> Igor> + int err= 0;
> Igor> + DBUG_ENTER("p_resize_key_cache");
> Igor> + if (use_mem == 0)
>
> Change to test if (cleanup)
Done
>
> Igor> + {
> Igor> + p_end_key_cache(keycache_cb, 0);
> Igor> + DBUG_RETURN(blocks);
>
> change to return -1
Done
>
> Igor> + }
> Igor> + for (i= 0; i < partitions; i++)
> Igor> + {
> Igor> + err|= s_prepare_resize_key_cache(keycache->partition_array[i], 0, 1);
> Igor> + }
> Igor> + if (!err && use_mem)
>
> You don't need to test use_mem here (you know it's not 0)
Corrected
>
> Igor> + blocks= p_init_key_cache(keycache_cb, key_cache_block_size, use_mem,
> Igor> + division_limit, age_threshold);
> Igor> + if (blocks > 0 && !cleanup)
>
> Cleanup is always 0 here (as otherwise we return -1 at function start
> functabove)
Corrected
>
> Igor> + {
> Igor> + for (i= 0; i < partitions; i++)
> Igor> + {
> Igor> + s_finish_resize_key_cache(keycache->partition_array[i], 0, 1);
> Igor> + }
> Igor> + }
> Igor> + DBUG_RETURN(blocks);
> Igor> +}
>
> <cut>
>
>
> Igor> +static
> Igor> +void p_end_key_cache(void *keycache_cb, my_bool cleanup)
> Igor> +{
> Igor> + uint i;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint partitions= keycache->partitions;
> Igor> + DBUG_ENTER("p_end_key_cache");
> Igor> + DBUG_PRINT("enter", ("key_cache: 0x%lx", (long) keycache));
> Igor> +
> Igor> + for (i= 0; i < partitions; i++)
> Igor> + {
> Igor> + s_end_key_cache(keycache->partition_array[i], cleanup);
> Igor> + }
> Igor> + if (cleanup) {
>
> Move { to next line
Done.
>
> Igor> + for (i= 0; i < partitions; i++)
> Igor> + my_free((uchar*) keycache->partition_array[i], MYF(0));
> Igor> + my_free((uchar*) keycache->partition_array, MYF(0));
> Igor> + keycache->key_cache_inited= 0;
> Igor> + }
> Igor> + DBUG_VOID_RETURN;
> Igor> +}
>
> <cut>
>
> Offset variable can be used (it's only set).
Pardon me?
>
> Igor> +static
> Igor> +int p_key_cache_insert(void *keycache_cb,
> Igor> + File file, my_off_t filepos, int level,
> Igor> + uchar *buff, uint length)
> Igor> +{
> Igor> + uint w_length;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint offset= (uint) (filepos % keycache->key_cache_block_size);
> Igor> + DBUG_ENTER("p_key_cache_insert");
> Igor> + DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
> Igor> + (uint) file,(ulong) filepos, length));
> Igor> +
> Igor> +
> Igor> + /* Write data in key_cache_block_size increments */
> Igor> + do
> Igor> + {
> Igor> + S_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
> Igor> + file, filepos);
> Igor> + w_length= length;
> Igor> + set_if_smaller(w_length, keycache->key_cache_block_size);
>
> Should be:
> set_if_smaller(w_length, keycache->key_cache_block_size - offset);
Corrected
>
> Igor> + if (s_key_cache_insert((void *) partition,
> Igor> + file, filepos, level,
> Igor> + buff, w_length))
> Igor> + DBUG_RETURN(1);
> Igor> +
>
> <cut>
>
> Igor> +static
> Igor> +int p_key_cache_write(void *keycache_cb,
> Igor> + File file, void *file_extra,
> Igor> + my_off_t filepos, int level,
> Igor> + uchar *buff, uint length,
> Igor> + uint block_length __attribute__((unused)),
> Igor> + int dont_write)
> Igor> +{
> Igor> + uint w_length;
> Igor> + ulonglong *part_map= (ulonglong *) file_extra;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint offset= (uint) (filepos % keycache->key_cache_block_size);
> Igor> + DBUG_ENTER("p_key_cache_write");
> Igor> + DBUG_PRINT("enter",
> Igor> + ("fd: %u pos: %lu length: %u block_length: %u"
> Igor> + " key_block_length: %u",
> Igor> + (uint) file, (ulong) filepos, length, block_length,
> Igor> + keycache ? keycache->key_cache_block_size : 0));
> Igor> +
> Igor> +
> Igor> + /* Write data in key_cache_block_size increments */
> Igor> + do
> Igor> + {
> Igor> + S_KEY_CACHE_CB *partition= get_key_cache_partition_for_write(keycache,
> Igor> + file,
> Igor> filepos,
> Igor> + part_map);
> Igor> + w_length = length;
> Igor> + set_if_smaller(w_length, keycache->key_cache_block_size );
>
> Should be:
> set_if_smaller(w_length, keycache->key_cache_block_size - offset);
Corrected
>
> Igor> + if (s_key_cache_write(partition,
> Igor> + file, 0, filepos, level,
> Igor> + buff, w_length, block_length,
> Igor> + dont_write))
> Igor> + DBUG_RETURN(1);
>
> <cut>
>
> Igor> +static
> Igor> +int p_flush_key_blocks(void *keycache_cb,
> Igor> + File file, void *file_extra,
> Igor> + enum flush_type type)
> Igor> +{
> Igor> + uint i;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint partitions= keycache->partitions;
> Igor> + int err= 0;
> Igor> + ulonglong *dirty_part_map= (ulonglong *) file_extra;
> Igor> + DBUG_ENTER("p_flush_key_blocks");
> Igor> + DBUG_PRINT("enter", ("keycache: 0x%lx", (long) keycache));
> Igor> +
> Igor> + for (i= 0; i < partitions; i++)
> Igor> + {
> Igor> + S_KEY_CACHE_CB *partition= keycache->partition_array[i];
> Igor> + if ((type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE) &&
> Igor> + !((*dirty_part_map) & (1<<i)))
>
> Change 1<<i to ((ulonglong) 1 << i)
Corrected
>
> Igor> + continue;
> Igor> + err+= test(s_flush_key_blocks(partition, file, 0, type));
>
> You can change the + to |, and then remove the err > 0 below.
Corrected
>
> Igor> + }
> Igor> + *dirty_part_map= 0;
> Igor> +
> Igor> + if (err > 0)
> Igor> + err= 1;
> Igor> +
> Igor> + DBUG_RETURN(err);
> Igor> +}
>
> <cut>
>
> Igor> +static
> Igor> +void p_get_key_cache_statistics(void *keycache_cb, uint partition_no,
> Igor> + KEY_CACHE_STATISTICS *key_cache_stats)
> Igor> +{
> Igor> + uint i;
> Igor> + S_KEY_CACHE_CB *partition;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint partitions= keycache->partitions;
> Igor> + DBUG_ENTER("p_get_key_cache_statistics_");
> Igor> +
> Igor> + if (partition_no != 0)
> Igor> + {
> Igor> + partition= keycache->partition_array[partition_no-1];
> Igor> + s_get_key_cache_statistics((void *) partition, 0, key_cache_stats);
> Igor> + DBUG_VOID_RETURN;
> Igor> + }
> Igor> + key_cache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
> Igor> + key_cache_stats->block_size= (longlong) keycache->key_cache_block_size;
> Igor> + for (i = 0; i < partitions; i++)
> Igor> + {
> Igor> + partition= keycache->partition_array[i];
> Igor> + key_cache_stats->blocks_used+= partition->blocks_used;
> Igor> + key_cache_stats->blocks_unused+= partition->blocks_unused;
> Igor> + key_cache_stats->blocks_changed+= partition->global_blocks_changed;
> Igor> + key_cache_stats->read_requests+= partition->global_cache_r_requests;
> Igor> + key_cache_stats->reads+= partition->global_cache_read;
> Igor> + key_cache_stats->write_requests+= partition->global_cache_w_requests;
> Igor> + key_cache_stats->writes+= partition->global_cache_write;
> Igor> + }
>
> Shouldn't you start by reseting key_cache_stats ?
> I think it's better to do the reset here than in
> get_key_cache_statistics()
>
> As you don't need the reset when you call s_get_key_cache_statistics()
> (as this overwrites all stats entries)
Corrected
>
> Igor> + DBUG_VOID_RETURN;
> Igor> +}
>
> <cut>
>
> Igor> +static
> Igor> +ulonglong p_get_key_cache_stat_value(void *keycache_cb, uint var_no)
> Igor> +{
> Igor> + uint i;
> Igor> + P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
> Igor> + uint partitions= keycache->partitions;
> Igor> + size_t var_ofs= s_key_cache_stat_var_offsets[var_no];
> Igor> + ulonglong res= 0;
> Igor> + DBUG_ENTER("p_get_key_cache_stat_value");
> Igor> +
> Igor> + if (var_no < 3)
>
> Change to define (see earlier comment)
>
> <cut>
>
> Igor> +int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
> Igor> + size_t use_mem, uint division_limit,
> Igor> + uint age_threshold, uint partitions)
> Igor> +{
> Igor> + void *keycache_cb;
> Igor> + int blocks;
> Igor> + if (keycache->key_cache_inited)
> Igor> + keycache_cb= keycache->keycache_cb;
>
> See earlier comment about making this a parameter.
>
> <cut>
>
> Igor> +int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
> Igor> + size_t use_mem, uint division_limit, uint age_threshold)
> Igor> +{
> Igor> + int blocks= -1;
> Igor> + if (keycache->key_cache_inited)
> Igor> + {
> Igor> + if ((uint) keycache->param_partitions != keycache->partitions &&
> Igor> use_mem)
> Igor> + blocks= repartition_key_cache (keycache,
> Igor> + key_cache_block_size, use_mem,
> Igor> + division_limit, age_threshold,
> Igor> + (uint) keycache->param_partitions);
>
> Remove space after function name
Done
>
> Igor> + else
> Igor> + {
> Igor> + blocks= keycache->interface_funcs->resize(keycache->keycache_cb,
> Igor> + key_cache_block_size,
> Igor> + use_mem, division_limit,
> Igor> + age_threshold);
> Igor> +
> Igor> + if (keycache->partitions)
> Igor> + keycache->partitions=
> Igor> + ((P_KEY_CACHE_CB *)(keycache->keycache_cb))->partitions;
> Igor> + }
> Igor> + if (blocks <= 0)
> Igor> + keycache->can_be_used= 0;
>
> The last should probably be:
>
> keycache->can_be_used= (blocks >= 0);
Corrected
>
> Safer, as it ensures that can_be_used is always correct.
>
>
> Igor> +uchar *key_cache_read(KEY_CACHE *keycache,
> Igor> + File file, my_off_t filepos, int level,
> Igor> + uchar *buff, uint length,
> Igor> + uint block_length, int return_buffer)
> Igor> +{
> Igor> + if (keycache->key_cache_inited && keycache->can_be_used)
>
> Could we change this to only depend on keycache->can_be_used ?
>
> (Faster if)
>
> We can of course assume that keycache_init() has been called for the object.
It means that each caller should check this condition. Is it good?
>
> Igor> + return keycache->interface_funcs->read(keycache->keycache_cb,
> Igor> + file, filepos, level,
> Igor> + buff, length,
> Igor> + block_length, return_buffer);
> Igor> +
> Igor> + /* We can't use mutex here as the key cache may not be initialized */
> Igor> + keycache->global_cache_r_requests++;
> Igor> + keycache->global_cache_read++;
> Igor> +
> Igor> + if (my_pread(file, (uchar*) buff, length, filepos, MYF(MY_NABP)))
> Igor> + return (uchar *) 0;
> Igor> +
> Igor> + return buff;
> Igor> +}
>
> <cut>
>
> Igor> +int key_cache_insert(KEY_CACHE *keycache,
> Igor> + File file, my_off_t filepos, int level,
> Igor> + uchar *buff, uint length)
> Igor> +{
> Igor> + if (keycache->key_cache_inited && keycache->can_be_used)
>
> Same here as above.
>
> Igor> + return keycache->interface_funcs->insert(keycache->keycache_cb,
> Igor> + file, filepos, level,
> Igor> + buff, length);
> Igor> + return 0;
> Igor> +}
> Igor> +
>
> <cut>
>
> Igor> +int key_cache_write(KEY_CACHE *keycache,
> Igor> + File file, void *file_extra,
> Igor> + my_off_t filepos, int level,
> Igor> + uchar *buff, uint length,
> Igor> + uint block_length, int force_write)
> Igor> +{
> Igor> + if (keycache->key_cache_inited && keycache->can_be_used)
>
> And here.
>
> Igor> +void get_key_cache_statistics(KEY_CACHE *keycache, uint partition_no,
> Igor> + KEY_CACHE_STATISTICS *key_cache_stats)
> Igor> +{
> Igor> + bzero(key_cache_stats, sizeof(KEY_CACHE_STATISTICS));
>
> Remove the above; Better to assume that get_stats() overwrites this.
> (Which is the case for s_get_key_cache_statistics())
Done.
>
> <cut>
>
> Igor> === modified file 'sql/handler.cc'
> Igor> --- a/sql/handler.cc 2010-02-01 06:14:12 +0000
>
> Igor> +int ha_repartition_key_cache(KEY_CACHE *key_cache)
> Igor> +{
> Igor> + DBUG_ENTER("ha_repartition_key_cache");
> Igor> +
> Igor> + if (key_cache->key_cache_inited)
> Igor> + {
> Igor> + pthread_mutex_lock(&LOCK_global_system_variables);
> Igor> + size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
> Igor> + long tmp_block_size= (long) key_cache->param_block_size;
> Igor> + uint division_limit= key_cache->param_division_limit;
> Igor> + uint age_threshold= key_cache->param_age_threshold;
> Igor> + uint partitions= key_cache->param_partitions;
> Igor> + pthread_mutex_unlock(&LOCK_global_system_variables);
> Igor> + DBUG_RETURN(!repartition_key_cache(key_cache, tmp_block_size,
> Igor> + tmp_buff_size,
> Igor> + division_limit, age_threshold,
> Igor> + partitions));
> Igor> + }
>
> key_cache_inited may be 0 if we used a 0 size key cache.
> In this case one can't reparttion this cache. Is this correct?
> Assume on does the following:
>
> - Set key cache size to 0
> - changes partition numbers
> - set key cache to 1G
>
> In this case, will things work and the new key cache have the new
> number of partitions ?
> (It may work, just wanted to be sure that you have tested this)
Yes this is correct and works (e.g. we can start the server with the
partitioned default key cache).
>
> <cut>
> Igor> === modified file 'sql/sql_show.cc'
> Igor> --- a/sql/sql_show.cc 2010-02-01 06:14:12 +0000
> Igor> +++ b/sql/sql_show.cc 2010-02-16 16:41:11 +0000
> Igor> @@ -2220,6 +2220,31 @@ void remove_status_vars(SHOW_VAR *list)
> Igor> }
>
>
> Igor> +
> Igor> +static void update_key_cache_stat_var(KEY_CACHE *key_cache, size_t ofs)
> Igor> +{
> Igor> + uint var_no;
> Igor> + switch (ofs) {
> Igor> + case offsetof(KEY_CACHE, blocks_used):
> Igor> + case offsetof(KEY_CACHE, blocks_unused):
> Igor> + case offsetof(KEY_CACHE, global_blocks_changed):
> Igor> + var_no= (ofs-offsetof(KEY_CACHE, blocks_used))/sizeof(ulong);
> Igor> + *(ulong *)((char *) key_cache + ofs)=
> Igor> + (ulong) get_key_cache_stat_value(key_cache, var_no);
> Igor> + break;
> Igor> + case offsetof(KEY_CACHE, global_cache_r_requests):
> Igor> + case offsetof(KEY_CACHE, global_cache_read):
> Igor> + case offsetof(KEY_CACHE, global_cache_w_requests):
> Igor> + case offsetof(KEY_CACHE, global_cache_write):
> Igor> + var_no= 3+(ofs-offsetof(KEY_CACHE, global_cache_w_requests))/
> Igor> + sizeof(ulonglong);
>
> Change 3 to constant.
Done
>
> Igor> + *(ulonglong *)((char *) key_cache + ofs)=
> Igor> + get_key_cache_stat_value(key_cache, var_no);
> Igor> + break;
> Igor> + }
> Igor> +}
>
> <cut>
>
> Igor> +static
> Igor> +int store_key_cache_table_record(THD *thd, TABLE *table,
> Igor> + const char *name, uint name_length,
> Igor> + KEY_CACHE *key_cache,
> Igor> + uint partitions, uint partition_no)
> Igor> +{
> Igor> + KEY_CACHE_STATISTICS key_cache_stats;
> Igor> + uint err;
> Igor> + DBUG_ENTER("store_key_cache_table_record");
> Igor> +
> Igor> + get_key_cache_statistics(key_cache, partition_no, &key_cache_stats);
> Igor> +
> Igor> + if (key_cache_stats.mem_size == 0)
> Igor> + DBUG_RETURN(0);
>
> Shouldn't we also here test for keycache->key_cache_inited ?
Yes we should. Corrected.
>
> Regards,
> Monty
>
==========================================================================
Here's the fix:
#At lp:maria/5.2 based on
revid:igor@xxxxxxxxxxxx-20100331233728-obczp1ecrffnaa2s
2747 Igor Babaev 2010-04-01
Post-review fixes.
modified:
include/keycache.h
mysql-test/r/key_cache.result
mysql-test/t/key_cache.test
mysys/mf_keycache.c
sql/sql_show.cc
=== modified file 'include/keycache.h'
--- a/include/keycache.h 2010-02-16 16:41:11 +0000
+++ b/include/keycache.h 2010-04-01 21:42:40 +0000
@@ -37,7 +37,6 @@ C_MODE_START
#define MAX_KEY_CACHE_PARTITIONS 64
-
/* The structure to get statistical data about a key cache */
typedef struct st_key_cache_statistics
@@ -53,6 +52,8 @@ typedef struct st_key_cache_statistics
ulonglong writes; /* number of actual writes from buffers into
files */
} KEY_CACHE_STATISTICS;
+#define NO_LONG_KEY_CACHE_STAT_VARIABLES 3
+
/* The type of a key cache object */
typedef enum key_cache_type
{
@@ -61,6 +62,55 @@ typedef enum key_cache_type
} KEY_CACHE_TYPE;
+typedef
+ int (*INIT_KEY_CACHE)
+ (void *, uint key_cache_block_size,
+ size_t use_mem, uint division_limit, uint age_threshold);
+typedef
+ int (*RESIZE_KEY_CACHE)
+ (void *, uint key_cache_block_size,
+ size_t use_mem, uint division_limit, uint age_threshold);
+typedef
+ void (*CHANGE_KEY_CACHE_PARAM)
+ (void *keycache_cb,
+ uint division_limit, uint age_threshold);
+typedef
+ uchar* (*KEY_CACHE_READ)
+ (void *keycache_cb,
+ File file, my_off_t filepos, int level,
+ uchar *buff, uint length,
+ uint block_length, int return_buffer);
+typedef
+ int (*KEY_CACHE_INSERT)
+ (void *keycache_cb,
+ File file, my_off_t filepos, int level,
+ uchar *buff, uint length);
+typedef
+ int (*KEY_CACHE_WRITE)
+ (void *keycache_cb,
+ File file, void *file_extra,
+ my_off_t filepos, int level,
+ uchar *buff, uint length,
+ uint block_length, int force_write);
+typedef
+ int (*FLUSH_KEY_BLOCKS)
+ (void *keycache_cb,
+ int file, void *file_extra,
+ enum flush_type type);
+typedef
+ int (*RESET_KEY_CACHE_COUNTERS)
+ (const char *name, void *keycache_cb);
+typedef
+ void (*END_KEY_CACHE)
+ (void *keycache_cb, my_bool cleanup);
+typedef
+ void (*GET_KEY_CACHE_STATISTICS)
+ (void *keycache_cb, uint partition_no,
+ KEY_CACHE_STATISTICS *key_cache_stats);
+typedef
+ ulonglong (*GET_KEY_CACHE_STAT_VALUE)
+ (void *keycache_cb, uint var_no);
+
/*
An object of the type KEY_CACHE_FUNCS contains pointers to all functions
from the key cache interface.
@@ -74,32 +124,17 @@ typedef enum key_cache_type
typedef struct st_key_cache_funcs
{
- int (*init) (void *, uint key_cache_block_size,
- size_t use_mem, uint division_limit, uint
age_threshold);
- int (*resize) (void *, uint key_cache_block_size,
- size_t use_mem, uint division_limit, uint
age_threshold);
- void (*change_param) (void *keycache_cb,
- uint division_limit, uint age_threshold);
- uchar* (*read) (void *keycache_cb,
- File file, my_off_t filepos, int level,
- uchar *buff, uint length,
- uint block_length, int return_buffer);
- int (*insert) (void *keycache_cb,
- File file, my_off_t filepos, int level,
- uchar *buff, uint length);
- int (*write) (void *keycache_cb,
- File file, void *file_extra,
- my_off_t filepos, int level,
- uchar *buff, uint length,
- uint block_length, int force_write);
- int (*flush) (void *keycache_cb,
- int file, void *file_extra,
- enum flush_type type);
- int (*reset_counters) (const char *name, void *keycache_cb);
- void (*end) (void *keycache_cb, my_bool cleanup);
- void (*get_stats) (void *keycache_cb, uint partition_no,
- KEY_CACHE_STATISTICS *key_cache_stats);
- ulonglong (*get_stat_val) (void *keycache_cb, uint var_no);
+ INIT_KEY_CACHE init;
+ RESIZE_KEY_CACHE resize;
+ CHANGE_KEY_CACHE_PARAM change_param;
+ KEY_CACHE_READ read;
+ KEY_CACHE_INSERT insert;
+ KEY_CACHE_WRITE write;
+ FLUSH_KEY_BLOCKS flush;
+ RESET_KEY_CACHE_COUNTERS reset_counters;
+ END_KEY_CACHE end;
+ GET_KEY_CACHE_STATISTICS get_stats;
+ GET_KEY_CACHE_STAT_VALUE get_stat_val;
} KEY_CACHE_FUNCS;
=== modified file 'mysql-test/r/key_cache.result'
--- a/mysql-test/r/key_cache.result 2010-03-31 23:37:28 +0000
+++ b/mysql-test/r/key_cache.result 2010-04-01 21:42:40 +0000
@@ -672,12 +672,12 @@ insert into t2 values (2000, 3, 'yyyy');
select * from information_schema.key_caches where key_cache_name like
"keycache2"
and partition_number
is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
-keycache2 NULL NULL 1048576 1024 0 # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 6 # 0 6 6 3 3
select * from information_schema.key_caches where key_cache_name like
"key%"
and partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
keycache1 7 NULL 262143 2048 25 # 0 2082 25 1071 19
-keycache2 NULL NULL 1048576 1024 0 # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 6 # 0 6 6 3 3
cache index t2 in keycache1;
Table Op Msg_type Msg_text
test.t2 assign_to_keycache status OK
@@ -718,7 +718,7 @@ KEY_CACHE_NAME PARTITIONS PARTITION_NUMB
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
keycache1 7 NULL 262143 2048 # # 0 3201 43 1594 30
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_cache_block_size=2*1024;
insert into t2 values (7000, 3, 'yyyy');
select * from information_schema.key_caches where partition_number is null;
@@ -726,66 +726,72 @@ KEY_CACHE_NAME PARTITIONS PARTITION_NUMB
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
keycache1 7 NULL 262143 2048 # # 0 6 6 3 3
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_cache_block_size=8*1024;
+select * from information_schema.key_caches where partition_number is null;
+KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
+default 2 NULL 32768 1024 # # 0 3172 24 1552 18
+small NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache1 3 NULL 262143 8192 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
insert into t2 values (8000, 3, 'yyyy');
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
keycache1 3 NULL 262143 8192 # # 0 6 5 3 3
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_buffer_size=64*1024;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_cache_block_size=2*1024;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
keycache1 3 NULL 65535 2048 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_cache_block_size=8*1024;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_buffer_size=0;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_cache_block_size=8*1024;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_buffer_size=0;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_buffer_size=128*1024;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
keycache1 1 NULL 131072 8192 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
set global keycache1.key_cache_block_size=1024;
select * from information_schema.key_caches where partition_number is null;
KEY_CACHE_NAME PARTITIONS PARTITION_NUMBER FULL_SIZE BLOCK_SIZE
USED_BLOCKS UNUSED_BLOCKS DIRTY_BLOCKS READ_REQUESTS READS
WRITE_REQUESTS WRITES
default 2 NULL 32768 1024 # # 0 3172 24 1552 18
small NULL NULL 1048576 1024 # # 0 0 0 0 0
keycache1 7 NULL 131068 1024 # # 0 0 0 0 0
-keycache2 NULL NULL 1048576 1024 # # 0 0 0 0 0
+keycache2 NULL NULL 1048576 1024 # # 0 6 6 3 3
drop table t1,t2;
set global keycache1.key_buffer_size=0;
set global keycache2.key_buffer_size=0;
=== modified file 'mysql-test/t/key_cache.test'
--- a/mysql-test/t/key_cache.test 2010-03-31 23:37:28 +0000
+++ b/mysql-test/t/key_cache.test 2010-04-01 21:42:40 +0000
@@ -469,6 +469,8 @@ insert into t2 values (7000, 3, 'yyyy');
select * from information_schema.key_caches where partition_number is null;
set global keycache1.key_cache_block_size=8*1024;
+--replace_column 6 # 7 #
+select * from information_schema.key_caches where partition_number is null;
insert into t2 values (8000, 3, 'yyyy');
--replace_column 6 # 7 #
select * from information_schema.key_caches where partition_number is null;
=== modified file 'mysys/mf_keycache.c'
--- a/mysys/mf_keycache.c 2010-02-16 16:41:11 +0000
+++ b/mysys/mf_keycache.c 2010-04-01 21:42:40 +0000
@@ -49,6 +49,7 @@
One cache can handle many files.
It must contain buffers of the same blocksize.
+
init_key_cache() should be used to init cache handler.
The free list (free_block_list) is a stack like structure.
@@ -151,7 +152,7 @@ typedef struct st_keycache_wqueue
/* Control block for a simple (non-partitioned) key cache */
-typedef struct st_s_key_cache_cb
+typedef struct st_simple_key_cache_cb
{
my_bool key_cache_inited; /* <=> control block is allocated
*/
my_bool in_resize; /* true during resize operation
*/
@@ -202,7 +203,7 @@ typedef struct st_s_key_cache_cb
int blocks; /* max number of blocks in the cache
*/
uint hash_factor; /* factor used to calculate hash
function */
my_bool in_init; /* Set to 1 in MySQL during init/resize */
-} S_KEY_CACHE_CB;
+} SIMPLE_KEY_CACHE_CB;
/*
Some compilation flags have been added specifically for this module
@@ -314,12 +315,8 @@ KEY_CACHE *dflt_key_cache= &dflt_key_cac
#define FLUSH_CACHE 2000 /* sort this many blocks at
once */
-static int flush_all_key_blocks(S_KEY_CACHE_CB *keycache);
-/*
-static void s_change_key_cache_param(void *keycache_cb, uint
division_limit,
- uint age_threshold);
-*/
-static void s_end_key_cache(void *keycache_cb, my_bool cleanup);
+static int flush_all_key_blocks(SIMPLE_KEY_CACHE_CB *keycache);
+static void end_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache, my_bool
cleanup);
#ifdef THREAD
static void wait_on_queue(KEYCACHE_WQUEUE *wqueue,
pthread_mutex_t *mutex);
@@ -328,9 +325,9 @@ static void release_whole_queue(KEYCACHE
#define wait_on_queue(wqueue, mutex) do {} while (0)
#define release_whole_queue(wqueue) do {} while (0)
#endif
-static void free_block(S_KEY_CACHE_CB *keycache, BLOCK_LINK *block);
+static void free_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block);
#if !defined(DBUG_OFF)
-static void test_key_cache(S_KEY_CACHE_CB *keycache,
+static void test_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
const char *where, my_bool lock);
#endif
#define KEYCACHE_BASE_EXPR(f, pos)
\
@@ -433,7 +430,7 @@ static int keycache_pthread_cond_signal(
#define inline /* disabled inline for easier debugging */
static int fail_block(BLOCK_LINK *block);
static int fail_hlink(HASH_LINK *hlink);
-static int cache_empty(S_KEY_CACHE_CB *keycache);
+static int cache_empty(SIMPLE_KEY_CACHE_CB *keycache);
#endif
@@ -447,8 +444,8 @@ static inline uint next_power(uint value
Initialize a simple key cache
SYNOPSIS
- s_init_key_cache()
- keycache_cb pointer to the control block of a simple
key cache
+ init_simple_key_cache()
+ keycache pointer to the control block of a simple
key cache
key_cache_block_size size of blocks to keep cached data
use_mem memory to use for the key cache
buferrs/structures
division_limit division limit (may be zero)
@@ -458,8 +455,8 @@ static inline uint next_power(uint value
This function is the implementation of the init_key_cache interface
function that is employed by simple (non-partitioned) key caches.
The function builds a simple key cache and initializes the control
block
- structure of the type S_KEY_CACHE_CB that is used for this key cache.
- The parameter keycache_cb is supposed to point to this structure.
+ structure of the type SIMPLE_KEY_CACHE_CB that is used for this key
cache.
+ The parameter keycache is supposed to point to this structure.
The parameter key_cache_block_size specifies the size of the blocks in
the key cache to be built. The parameters division_limit and
age_threshhold
determine the initial values of those characteristics of the key cache
@@ -478,19 +475,17 @@ static inline uint next_power(uint value
It's assumed that no two threads call this function simultaneously
referring to the same key cache handle.
-
*/
static
-int s_init_key_cache(void *keycache_cb, uint key_cache_block_size,
- size_t use_mem, uint division_limit,
- uint age_threshold)
+int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache, uint
key_cache_block_size,
+ size_t use_mem, uint division_limit,
+ uint age_threshold)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
ulong blocks, hash_links;
size_t length;
int error;
- DBUG_ENTER("init_key_cache");
+ DBUG_ENTER("init_simple_key_cache");
DBUG_ASSERT(key_cache_block_size >= 512);
KEYCACHE_DEBUG_OPEN;
@@ -653,16 +648,16 @@ err:
Prepare for resizing a simple key cache
SYNOPSIS
- s_prepare_resize_key_cache()
- keycache_cb pointer to the control block of a simple
key cache
+ prepare_resize_simple_key_cache()
+ keycache pointer to the control block of a simple
key cache
with_resize_queue <=> resize queue is used
release_lock <=> release the key cache lock before return
DESCRIPTION
This function flushes all dirty pages from a simple key cache and after
- this it destroys the key cache calling s_end_key_cache. The function
- considers the parameter keycache_cb as a pointer to the control block
- structure of the type S_KEY_CACHE_CB for this key cache.
+ this it destroys the key cache calling end_simple_key_cache. The
function
+ takes the parameter keycache as a pointer to the control block
+ structure of the type SIMPLE_KEY_CACHE_CB for this key cache.
The parameter with_resize_queue determines weather the resize queue is
involved (MySQL server never uses this queue). The parameter
release_lock
says weather the key cache lock must be released before return from
@@ -673,19 +668,18 @@ err:
1 - otherwise.
NOTES
- This function is the called by s_resize_key_cache and
p_resize_key_cache
- that resize simple and partitioned key caches respectively.
-
+ This function is the called by resize_simple_key_cache and
+ resize_partitioned_key_cache that resize simple and partitioned key
caches
+ respectively.
*/
static
-int s_prepare_resize_key_cache(void *keycache_cb,
- my_bool with_resize_queue,
- my_bool release_lock)
+int prepare_resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
+ my_bool with_resize_queue,
+ my_bool release_lock)
{
int res= 0;
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- DBUG_ENTER("s_prepare_resize_key_cache");
+ DBUG_ENTER("prepare_resize_simple_key_cache");
keycache_pthread_mutex_lock(&keycache->cache_lock);
@@ -749,7 +743,7 @@ int s_prepare_resize_key_cache(void *key
KEYCACHE_DBUG_ASSERT(keycache->cnt_for_resize_op == 0);
#endif
- s_end_key_cache(keycache_cb, 0);
+ end_simple_key_cache(keycache, 0);
finish:
if (release_lock)
@@ -762,16 +756,16 @@ finish:
Finalize resizing a simple key cache
SYNOPSIS
- s_finish_resize_key_cache()
- keycache_cb pointer to the control block of a simple
key cache
+ finish_resize_simple_key_cache()
+ keycache pointer to the control block of a simple
key cache
with_resize_queue <=> resize queue is used
acquire_lock <=> acquire the key cache lock at start
DESCRIPTION
This function performs finalizing actions for the operation of
- resizing a simple key cache. The function considers the parameter
- keycache_cb as a pointer to the control block structure of the type
- S_KEY_CACHE_CB for this key cache. The function sets the flag
+ resizing a simple key cache. The function takes the parameter
+ keycache as a pointer to the control block structure of the type
+ SIMPLE_KEY_CACHE_CB for this key cache. The function sets the flag
in_resize in this structure to FALSE.
The parameter with_resize_queue determines weather the resize queue
is involved (MySQL server never uses this queue).
@@ -782,22 +776,23 @@ finish:
none
NOTES
- This function is the called by s_resize_key_cache and
p_resize_key_cache
- that resize simple and partitioned key caches respectively.
-
+ This function is the called by resize_simple_key_cache and
+ resize_partitioned_key_cache that resize simple and partitioned key
caches
+ respectively.
*/
static
-void s_finish_resize_key_cache(void *keycache_cb,
- my_bool with_resize_queue,
- my_bool acquire_lock)
+void finish_resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
+ my_bool with_resize_queue,
+ my_bool acquire_lock)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- DBUG_ENTER("s_finish_resize_key_cache");
+ DBUG_ENTER("finish_resize_simple_key_cache");
if (acquire_lock)
keycache_pthread_mutex_lock(&keycache->cache_lock);
-
+
+ safe_mutex_assert_owner(&keycache->cache_lock);
+
/*
Mark the resize finished. This allows other threads to start a
resize or to request new cache blocks.
@@ -820,8 +815,8 @@ void s_finish_resize_key_cache(void *key
Resize a simple key cache
SYNOPSIS
- s_resize_key_cache()
- keycache_cb pointer to the control block of a simple
key cache
+ resize_simple_key_cache()
+ keycache pointer to the control block of a simple
key cache
key_cache_block_size size of blocks to keep cached data
use_mem memory to use for the key cache
buffers/structures
division_limit new division limit (if not zero)
@@ -830,8 +825,8 @@ void s_finish_resize_key_cache(void *key
DESCRIPTION
This function is the implementation of the resize_key_cache interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for the simple key
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for the
simple key
cache to be resized.
The parameter key_cache_block_size specifies the new size of the
blocks in
the key cache. The parameters division_limit and age_threshold
@@ -845,47 +840,45 @@ void s_finish_resize_key_cache(void *key
0 - otherwise.
NOTES.
- The function first calls the function s_prepare_resize_key_cache
+ The function first calls the function prepare_resize_simple_key_cache
to flush all dirty blocks from key cache, to free memory used
for key cache blocks and auxiliary structures. After this the
function builds a new key cache with new parameters.
This implementation doesn't block the calls and executions of other
functions from the key cache interface. However it assumes that the
- calls of s_resize_key_cache itself are serialized.
+ calls of resize_simple_key_cache itself are serialized.
The function starts the operation only when all other threads
performing operations with the key cache let her to proceed
(when cnt_for_resize=0).
-
*/
static
-int s_resize_key_cache(void *keycache_cb, uint key_cache_block_size,
- size_t use_mem, uint division_limit,
- uint age_threshold)
+int resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache, uint
key_cache_block_size,
+ size_t use_mem, uint division_limit,
+ uint age_threshold)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
int blocks= 0;
- DBUG_ENTER("s_resize_key_cache");
+ DBUG_ENTER("resize_simple_key_cache");
if (!keycache->key_cache_inited)
- DBUG_RETURN(keycache->disk_blocks);
+ DBUG_RETURN(blocks);
/*
Note that the cache_lock mutex and the resize_queue are left untouched.
We do not lose the cache_lock and will release it only at the end of
this function.
*/
- if (s_prepare_resize_key_cache(keycache_cb, 1, 0))
+ if (prepare_resize_simple_key_cache(keycache, 1, 0))
goto finish;
/* The following will work even if use_mem is 0 */
- blocks= s_init_key_cache(keycache, key_cache_block_size, use_mem,
- division_limit, age_threshold);
+ blocks= init_simple_key_cache(keycache, key_cache_block_size, use_mem,
+ division_limit, age_threshold);
finish:
- s_finish_resize_key_cache(keycache_cb, 1, 0);
+ finish_resize_simple_key_cache(keycache, 1, 0);
DBUG_RETURN(blocks);
}
@@ -894,7 +887,7 @@ finish:
/*
Increment counter blocking resize key cache operation
*/
-static inline void inc_counter_for_resize_op(S_KEY_CACHE_CB *keycache)
+static inline void inc_counter_for_resize_op(SIMPLE_KEY_CACHE_CB *keycache)
{
keycache->cnt_for_resize_op++;
}
@@ -904,7 +897,7 @@ static inline void inc_counter_for_resiz
Decrement counter blocking resize key cache operation;
Signal the operation to proceed when counter becomes equal zero
*/
-static inline void dec_counter_for_resize_op(S_KEY_CACHE_CB *keycache)
+static inline void dec_counter_for_resize_op(SIMPLE_KEY_CACHE_CB *keycache)
{
if (!--keycache->cnt_for_resize_op)
release_whole_queue(&keycache->waiting_for_resize_cnt);
@@ -915,16 +908,16 @@ static inline void dec_counter_for_resiz
Change key cache parameters of a simple key cache
SYNOPSIS
- s_change_key_cache_param()
- keycache_cb pointer to the control block of a simple
key cache
+ change_simple_key_cache_param()
+ keycache pointer to the control block of a simple
key cache
division_limit new division limit (if not zero)
age_threshold new age threshold (if not zero)
DESCRIPTION
This function is the implementation of the change_key_cache_param
interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for the simple key
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for the
simple key
cache where new values of the division limit and the age threshold used
for midpoint insertion strategy are to be set. The parameters
division_limit and age_threshold provide these new values.
@@ -938,15 +931,13 @@ static inline void dec_counter_for_resiz
This function changes some parameters of a given key cache without
reformatting it. The function does not touch the contents the key
cache blocks.
-
*/
static
-void s_change_key_cache_param(void *keycache_cb, uint division_limit,
- uint age_threshold)
+void change_simple_key_cache_param(SIMPLE_KEY_CACHE_CB *keycache, uint
division_limit,
+ uint age_threshold)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- DBUG_ENTER("s_change_key_cache_param");
+ DBUG_ENTER("change_simple_key_cache_param");
keycache_pthread_mutex_lock(&keycache->cache_lock);
if (division_limit)
keycache->min_warm_blocks= (keycache->disk_blocks *
@@ -963,15 +954,15 @@ void s_change_key_cache_param(void *keyc
Destroy a simple key cache
SYNOPSIS
- s_end_key_cache()
- keycache_cb pointer to the control block of a simple
key cache
+ end_simple_key_cache()
+ keycache pointer to the control block of a simple
key cache
cleanup <=> complete free (free also mutex for key
cache)
DESCRIPTION
This function is the implementation of the end_key_cache interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for the simple key
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for the
simple key
cache to be destroyed.
The function frees the memory allocated for the key cache blocks and
auxiliary structures. If the value of the parameter cleanup is TRUE
@@ -982,10 +973,9 @@ void s_change_key_cache_param(void *keyc
*/
static
-void s_end_key_cache(void *keycache_cb, my_bool cleanup)
+void end_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache, my_bool cleanup)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- DBUG_ENTER("s_end_key_cache");
+ DBUG_ENTER("end_simple_key_cache");
DBUG_PRINT("enter", ("key_cache: 0x%lx", (long) keycache));
if (!keycache->key_cache_inited)
@@ -1276,7 +1266,7 @@ static inline void link_changed(BLOCK_LI
void
*/
-static void link_to_file_list(S_KEY_CACHE_CB *keycache,
+static void link_to_file_list(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int file,
my_bool unlink_block)
{
@@ -1317,7 +1307,7 @@ static void link_to_file_list(S_KEY_CACH
void
*/
-static void link_to_changed_list(S_KEY_CACHE_CB *keycache,
+static void link_to_changed_list(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
DBUG_ASSERT(block->status & BLOCK_IN_USE);
@@ -1372,8 +1362,8 @@ static void link_to_changed_list(S_KEY_C
not linked in the LRU ring.
*/
-static void link_block(S_KEY_CACHE_CB *keycache, BLOCK_LINK *block,
my_bool hot,
- my_bool at_end)
+static void link_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block,
+ my_bool hot, my_bool at_end)
{
BLOCK_LINK *ins;
BLOCK_LINK **pins;
@@ -1493,7 +1483,7 @@ static void link_block(S_KEY_CACHE_CB *k
See NOTES for link_block
*/
-static void unlink_block(S_KEY_CACHE_CB *keycache, BLOCK_LINK *block)
+static void unlink_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block)
{
DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ |
BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link); /*backptr to block NULL from
free_block()*/
@@ -1551,7 +1541,8 @@ static void unlink_block(S_KEY_CACHE_CB
RETURN
void
*/
-static void reg_requests(S_KEY_CACHE_CB *keycache, BLOCK_LINK *block,
int count)
+static void reg_requests(SIMPLE_KEY_CACHE_CB *keycache,
+ BLOCK_LINK *block, int count)
{
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT(block->hash_link);
@@ -1594,7 +1585,7 @@ static void reg_requests(S_KEY_CACHE_CB
not linked in the LRU ring.
*/
-static void unreg_request(S_KEY_CACHE_CB *keycache,
+static void unreg_request(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int at_end)
{
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
@@ -1683,7 +1674,7 @@ static void remove_reader(BLOCK_LINK *bl
signals on its termination
*/
-static void wait_for_readers(S_KEY_CACHE_CB *keycache,
+static void wait_for_readers(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
#ifdef THREAD
@@ -1732,7 +1723,7 @@ static inline void link_hash(HASH_LINK *
Remove a hash link from the hash table
*/
-static void unlink_hash(S_KEY_CACHE_CB *keycache, HASH_LINK *hash_link)
+static void unlink_hash(SIMPLE_KEY_CACHE_CB *keycache, HASH_LINK
*hash_link)
{
KEYCACHE_DBUG_PRINT("unlink_hash", ("fd: %u pos_ %lu #requests=%u",
(uint) hash_link->file,(ulong) hash_link->diskpos,
hash_link->requests));
@@ -1788,7 +1779,7 @@ static void unlink_hash(S_KEY_CACHE_CB *
Get the hash link for a page
*/
-static HASH_LINK *get_hash_link(S_KEY_CACHE_CB *keycache,
+static HASH_LINK *get_hash_link(SIMPLE_KEY_CACHE_CB *keycache,
int file, my_off_t filepos)
{
reg1 HASH_LINK *hash_link, **start;
@@ -1909,7 +1900,7 @@ restart:
waits until first of this operations links any block back.
*/
-static BLOCK_LINK *find_key_block(S_KEY_CACHE_CB *keycache,
+static BLOCK_LINK *find_key_block(SIMPLE_KEY_CACHE_CB *keycache,
File file, my_off_t filepos,
int init_hits_left,
int wrmode, int *page_st)
@@ -2669,7 +2660,7 @@ restart:
portion is less than read_length, but not less than min_length.
*/
-static void read_block(S_KEY_CACHE_CB *keycache,
+static void read_block(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, uint read_length,
uint min_length, my_bool primary)
{
@@ -2761,8 +2752,8 @@ static void read_block(S_KEY_CACHE_CB *k
SYNOPSIS
- s_key_cache_read()
- keycache_cb pointer to the control block of a simple key cache
+ simple_key_cache_read()
+ keycache pointer to the control block of a simple key cache
file handler for the file for the block of data to
be read
filepos position of the block of data in the file
level determines the weight of the data
@@ -2774,8 +2765,8 @@ static void read_block(S_KEY_CACHE_CB *k
DESCRIPTION
This function is the implementation of the key_cache_read interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for a simple key
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for a
simple key
cache.
In a general case the function reads a block of data from the key cache
into the buffer buff of the size specified by the parameter length. The
@@ -2799,20 +2790,18 @@ static void read_block(S_KEY_CACHE_CB *k
NOTES
Filepos must be a multiple of 'block_length', but it doesn't
have to be a multiple of key_cache_block_size;
-
*/
-uchar *s_key_cache_read(void *keycache_cb,
- File file, my_off_t filepos, int level,
- uchar *buff, uint length,
- uint block_length __attribute__((unused)),
- int return_buffer __attribute__((unused)))
+uchar *simple_key_cache_read(SIMPLE_KEY_CACHE_CB *keycache,
+ File file, my_off_t filepos, int level,
+ uchar *buff, uint length,
+ uint block_length __attribute__((unused)),
+ int return_buffer __attribute__((unused)))
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
my_bool locked_and_incremented= FALSE;
int error=0;
uchar *start= buff;
- DBUG_ENTER("s_key_cache_read");
+ DBUG_ENTER("simple_key_cache_read");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file, (ulong) filepos, length));
@@ -3010,8 +2999,8 @@ end:
Insert a block of file data from a buffer into a simple key cache
SYNOPSIS
- s_key_cache_insert()
- keycache_cb pointer to the control block of a simple key cache
+ simple_key_cache_insert()
+ keycache pointer to the control block of a simple key cache
file handler for the file to insert data from
filepos position of the block of data in the file to insert
level determines the weight of the data
@@ -3021,8 +3010,8 @@ end:
DESCRIPTION
This function is the implementation of the key_cache_insert interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for a simple key
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for a
simple key
cache.
The function writes a block of file data from a buffer into the key
cache.
The buffer is specified with the parameters buff and length - the
pointer
@@ -3045,11 +3034,10 @@ end:
*/
static
-int s_key_cache_insert(void *keycache_cb,
- File file, my_off_t filepos, int level,
- uchar *buff, uint length)
+int simple_key_cache_insert(SIMPLE_KEY_CACHE_CB *keycache,
+ File file, my_off_t filepos, int level,
+ uchar *buff, uint length)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
int error= 0;
DBUG_ENTER("key_cache_insert");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
@@ -3272,8 +3260,8 @@ int s_key_cache_insert(void *keycache_cb
SYNOPSIS
- s_key_cache_write()
- keycache_cb pointer to the control block of a simple key cache
+ simple_key_cache_write()
+ keycache pointer to the control block of a simple key cache
file handler for the file to write data to
file_extra maps of key cache partitions containing
dirty pages from file
@@ -3287,8 +3275,8 @@ int s_key_cache_insert(void *keycache_cb
DESCRIPTION
This function is the implementation of the key_cache_write interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for a simple key
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for a
simple key
cache.
In a general case the function copies data from a buffer into the key
cache. The buffer is specified with the parameters buff and length -
@@ -3304,7 +3292,8 @@ int s_key_cache_insert(void *keycache_cb
The parameter file_extra currently makes sense only for simple key
caches
that are elements of a partitioned key cache. It provides a pointer
to the
shared bitmap of the partitions that may contains dirty pages for
the file.
- This bitmap is used to optimize the function p_flush_key_blocks.
+ This bitmap is used to optimize the function
+ flush_partitioned_key_cache_blocks.
RETURN VALUE
0 if a success, 1 - otherwise.
@@ -3312,21 +3301,19 @@ int s_key_cache_insert(void *keycache_cb
NOTES
This implementation exploits the fact that the function is called only
when a thread has got an exclusive lock for the key file.
-
*/
static
-int s_key_cache_write(void *keycache_cb,
- File file, void *file_extra
__attribute__((unused)),
- my_off_t filepos, int level,
- uchar *buff, uint length,
- uint block_length __attribute__((unused)),
- int dont_write)
+int simple_key_cache_write(SIMPLE_KEY_CACHE_CB *keycache,
+ File file, void *file_extra
__attribute__((unused)),
+ my_off_t filepos, int level,
+ uchar *buff, uint length,
+ uint block_length __attribute__((unused)),
+ int dont_write)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
my_bool locked_and_incremented= FALSE;
int error=0;
- DBUG_ENTER("s_key_cache_write");
+ DBUG_ENTER("simple_key_cache_write");
DBUG_PRINT("enter",
("fd: %u pos: %lu length: %u block_length: %u"
" key_block_length: %u",
@@ -3641,7 +3628,7 @@ end:
Block must have a request registered on it.
*/
-static void free_block(S_KEY_CACHE_CB *keycache, BLOCK_LINK *block)
+static void free_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block)
{
KEYCACHE_THREAD_TRACE("free block");
KEYCACHE_DBUG_PRINT("free_block",
@@ -3781,7 +3768,7 @@ static int cmp_sec_link(BLOCK_LINK **a,
free used blocks if requested
*/
-static int flush_cached_blocks(S_KEY_CACHE_CB *keycache,
+static int flush_cached_blocks(SIMPLE_KEY_CACHE_CB *keycache,
File file, BLOCK_LINK **cache,
BLOCK_LINK **end,
enum flush_type type)
@@ -3909,7 +3896,7 @@ static int flush_cached_blocks(S_KEY_CAC
1 error
*/
-static int flush_key_blocks_int(S_KEY_CACHE_CB *keycache,
+static int flush_key_blocks_int(SIMPLE_KEY_CACHE_CB *keycache,
File file, enum flush_type type)
{
BLOCK_LINK *cache_buff[FLUSH_CACHE],**cache;
@@ -4349,8 +4336,8 @@ err:
SYNOPSIS
- s_flush_key_blocks()
- keycache_cb pointer to the control block of a simple key cache
+ flush_simple_key_blocks()
+ keycache pointer to the control block of a simple key cache
file handler for the file to flush to
file_extra maps of key cache partitions containing
dirty pages from file (not used)
@@ -4359,7 +4346,7 @@ err:
DESCRIPTION
This function is the implementation of the flush_key_blocks interface
function that is employed by simple (non-partitioned) key caches.
- The function considers the parameter keycache_cb as a pointer to the
+ The function takes the parameter keycache as a pointer to the
control block structure of the type S_KEY_CACHE_CB for a simple key
cache.
In a general case the function flushes the data from all dirty key
@@ -4378,16 +4365,14 @@ err:
NOTES
This implementation exploits the fact that the function is called only
when a thread has got an exclusive lock for the key file.
-
*/
static
-int s_flush_key_blocks(void *keycache_cb,
- File file,
- void *file_extra __attribute__((unused)),
- enum flush_type type)
+int flush_simple_key_cache_blocks(SIMPLE_KEY_CACHE_CB *keycache,
+ File file,
+ void *file_extra __attribute__((unused)),
+ enum flush_type type)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
int res= 0;
DBUG_ENTER("flush_key_blocks");
DBUG_PRINT("enter", ("keycache: 0x%lx", (long) keycache));
@@ -4440,7 +4425,7 @@ int s_flush_key_blocks(void *keycache_cb
!= 0 Error
*/
-static int flush_all_key_blocks(S_KEY_CACHE_CB *keycache)
+static int flush_all_key_blocks(SIMPLE_KEY_CACHE_CB *keycache)
{
BLOCK_LINK *block;
uint total_found;
@@ -4546,14 +4531,14 @@ static int flush_all_key_blocks(S_KEY_CA
Reset the counters of a simple key cache
SYNOPSIS
- s_reset_key_cache_counters()
+ reset_simple_key_cache_counters()
name the name of a key cache
- keycache_cb pointer to the control block of a simple key cache
+ keycache pointer to the control block of a simple key cache
DESCRIPTION
This function is the implementation of the reset_key_cache_counters
interface function that is employed by simple (non-partitioned) key
caches.
- The function considers the parameter keycache_cb as a pointer to the
+ The function takes the parameter keycache as a pointer to the
control block structure of the type S_KEY_CACHE_CB for a simple key
cache.
This function resets the values of all statistical counters for the key
cache to 0.
@@ -4561,15 +4546,13 @@ static int flush_all_key_blocks(S_KEY_CA
RETURN
0 on success (always because it can't fail)
-
*/
static
-int s_reset_key_cache_counters(const char *name __attribute__((unused)),
- void *keycache_cb)
+int reset_simple_key_cache_counters(const char *name
__attribute__((unused)),
+ SIMPLE_KEY_CACHE_CB *keycache)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- DBUG_ENTER("s_reset_key_cache_counters");
+ DBUG_ENTER("reset_simple_key_cache_counters");
if (!keycache->key_cache_inited)
{
DBUG_PRINT("info", ("Key cache %s not initialized.", name));
@@ -4590,9 +4573,10 @@ int s_reset_key_cache_counters(const cha
/*
Test if disk-cache is ok
*/
-static void test_key_cache(S_KEY_CACHE_CB *keycache
__attribute__((unused)),
- const char *where __attribute__((unused)),
- my_bool lock __attribute__((unused)))
+static
+void test_key_cache(SIMPLE_KEY_CACHE_CB *keycache __attribute__((unused)),
+ const char *where __attribute__((unused)),
+ my_bool lock __attribute__((unused)))
{
/* TODO */
}
@@ -4604,7 +4588,7 @@ static void test_key_cache(S_KEY_CACHE_C
#define MAX_QUEUE_LEN 100
-static void keycache_dump(S_KEY_CACHE_CB *keycache)
+static void keycache_dump(SIMPLE_KEY_CACHE_CB *keycache)
{
FILE *keycache_dump_file=fopen(KEYCACHE_DUMP_FILE, "w");
struct st_my_thread_var *last;
@@ -4844,7 +4828,7 @@ static int fail_hlink(HASH_LINK *hlink)
return 0; /* Let the assert fail. */
}
-static int cache_empty(S_KEY_CACHE_CB *keycache)
+static int cache_empty(SIMPLE_KEY_CACHE_CB *keycache)
{
int errcnt= 0;
int idx;
@@ -4887,54 +4871,57 @@ static int cache_empty(S_KEY_CACHE_CB *k
Get statistics for a simple key cache
SYNOPSIS
- get_key_cache_statistics()
- keycache_cb pointer to the control block of a simple key cache
+ get_simple_key_cache_statistics()
+ keycache pointer to the control block of a simple key cache
partition_no partition number (not used)
key_cache_stats OUT pointer to the structure for the returned
statistics
DESCRIPTION
This function is the implementation of the get_key_cache_statistics
interface function that is employed by simple (non-partitioned) key
caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for a simple key
cache.
- This function returns the statistical data for the key cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for a
simple key
+ cache. This function returns the statistical data for the key cache.
The parameter partition_no is not used by this function.
RETURN
none
-
*/
static
-void s_get_key_cache_statistics(void *keycache_cb,
- uint partition_no __attribute__((unused)),
- KEY_CACHE_STATISTICS *key_cache_stats)
-{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- DBUG_ENTER("s_get_key_cache_statistics");
-
- key_cache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
- key_cache_stats->block_size= (longlong) keycache->key_cache_block_size;
- key_cache_stats->blocks_used= keycache->blocks_used;
- key_cache_stats->blocks_unused= keycache->blocks_unused;
- key_cache_stats->blocks_changed= keycache->global_blocks_changed;
- key_cache_stats->read_requests= keycache->global_cache_r_requests;
- key_cache_stats->reads= keycache->global_cache_read;
- key_cache_stats->write_requests= keycache->global_cache_w_requests;
- key_cache_stats->writes= keycache->global_cache_write;
+void get_simple_key_cache_statistics(SIMPLE_KEY_CACHE_CB *keycache,
+ uint partition_no
__attribute__((unused)),
+ KEY_CACHE_STATISTICS *keycache_stats)
+{
+ DBUG_ENTER("simple_get_key_cache_statistics");
+
+ keycache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
+ keycache_stats->block_size= (longlong) keycache->key_cache_block_size;
+ keycache_stats->blocks_used= keycache->blocks_used;
+ keycache_stats->blocks_unused= keycache->blocks_unused;
+ keycache_stats->blocks_changed= keycache->global_blocks_changed;
+ keycache_stats->read_requests= keycache->global_cache_r_requests;
+ keycache_stats->reads= keycache->global_cache_read;
+ keycache_stats->write_requests= keycache->global_cache_w_requests;
+ keycache_stats->writes= keycache->global_cache_write;
DBUG_VOID_RETURN;
}
-static size_t s_key_cache_stat_var_offsets[]=
+/*
+ Offsets of the statistical values in the control block for a simple
key cache
+ The first NO_LONG_KEY_CACHE_STAT_VARIABLES=3 are of the ulong type
while the
+ remaining are of the ulonglong type.
+ */
+static size_t simple_key_cache_stat_var_offsets[]=
{
- offsetof(S_KEY_CACHE_CB, blocks_used),
- offsetof(S_KEY_CACHE_CB, blocks_unused),
- offsetof(S_KEY_CACHE_CB, global_blocks_changed),
- offsetof(S_KEY_CACHE_CB, global_cache_w_requests),
- offsetof(S_KEY_CACHE_CB, global_cache_write),
- offsetof(S_KEY_CACHE_CB, global_cache_r_requests),
- offsetof(S_KEY_CACHE_CB, global_cache_read)
+ offsetof(SIMPLE_KEY_CACHE_CB, blocks_used),
+ offsetof(SIMPLE_KEY_CACHE_CB, blocks_unused),
+ offsetof(SIMPLE_KEY_CACHE_CB, global_blocks_changed),
+ offsetof(SIMPLE_KEY_CACHE_CB, global_cache_w_requests),
+ offsetof(SIMPLE_KEY_CACHE_CB, global_cache_write),
+ offsetof(SIMPLE_KEY_CACHE_CB, global_cache_r_requests),
+ offsetof(SIMPLE_KEY_CACHE_CB, global_cache_read)
};
@@ -4942,16 +4929,16 @@ static size_t s_key_cache_stat_var_offse
Get the value of a statistical variable for a simple key cache
SYNOPSIS
- s_get_key_cache_stat_value()
- keycache_cb pointer to the control block of a simple key cache
+ get_simple_key_cache_stat_value()
+ keycache pointer to the control block of a simple key cache
var_no the ordered number of a statistical variable
DESCRIPTION
- This function is the implementation of the s_get_key_cache_stat_value
+ This function is the implementation of the
get_simple_key_cache_stat_value
interface function that is employed by simple (non-partitioned) key
caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type S_KEY_CACHE_CB for a simple key
cache.
- This function returns the value of the statistical variable var_no
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type SIMPLE_KEY_CACHE_CB for a
simple key
+ cache. This function returns the value of the statistical variable
var_no
for this key cache. The variables are numbered starting from 0 to 6.
RETURN
@@ -4960,12 +4947,12 @@ static size_t s_key_cache_stat_var_offse
*/
static
-ulonglong s_get_key_cache_stat_value(void *keycache_cb, uint var_no)
+ulonglong get_simple_key_cache_stat_value(SIMPLE_KEY_CACHE_CB *keycache,
+ uint var_no)
{
- S_KEY_CACHE_CB *keycache= (S_KEY_CACHE_CB *) keycache_cb;
- size_t var_ofs= s_key_cache_stat_var_offsets[var_no];
+ size_t var_ofs= simple_key_cache_stat_var_offsets[var_no];
ulonglong res= 0;
- DBUG_ENTER("s_get_key_cache_stat_value");
+ DBUG_ENTER("get_simple_key_cache_stat_value");
if (var_no < 3)
res= (ulonglong) (*(long *) ((char *) keycache + var_ofs));
@@ -4985,19 +4972,19 @@ ulonglong s_get_key_cache_stat_value(voi
the MySQL server code directly. We don't do it though.
*/
-static KEY_CACHE_FUNCS s_key_cache_funcs =
+static KEY_CACHE_FUNCS simple_key_cache_funcs =
{
- s_init_key_cache,
- s_resize_key_cache,
- s_change_key_cache_param,
- s_key_cache_read,
- s_key_cache_insert,
- s_key_cache_write,
- s_flush_key_blocks,
- s_reset_key_cache_counters,
- s_end_key_cache,
- s_get_key_cache_statistics,
- s_get_key_cache_stat_value
+ (INIT_KEY_CACHE) init_simple_key_cache,
+ (RESIZE_KEY_CACHE) resize_simple_key_cache,
+ (CHANGE_KEY_CACHE_PARAM) change_simple_key_cache_param,
+ (KEY_CACHE_READ) simple_key_cache_read,
+ (KEY_CACHE_INSERT) simple_key_cache_insert,
+ (KEY_CACHE_WRITE) simple_key_cache_write,
+ (FLUSH_KEY_BLOCKS) flush_simple_key_cache_blocks,
+ (RESET_KEY_CACHE_COUNTERS) reset_simple_key_cache_counters,
+ (END_KEY_CACHE) end_simple_key_cache,
+ (GET_KEY_CACHE_STATISTICS) get_simple_key_cache_statistics,
+ (GET_KEY_CACHE_STAT_VALUE) get_simple_key_cache_stat_value
};
@@ -5038,17 +5025,22 @@ static KEY_CACHE_FUNCS s_key_cache_funcs
/* Control block for a partitioned key cache */
-typedef struct st_p_key_cache_cb
+typedef struct st_partitioned_key_cache_cb
{
my_bool key_cache_inited; /*<=> control block is allocated
*/
- S_KEY_CACHE_CB **partition_array; /* array of the key cache
partitions */
- uint partitions; /* number of partitions in the key
cache */
+ SIMPLE_KEY_CACHE_CB **partition_array; /* the key cache partitions
*/
size_t key_cache_mem_size; /* specified size of the cache memory
*/
uint key_cache_block_size; /* size of the page buffer of a cache
block */
-} P_KEY_CACHE_CB;
+ uint partitions; /* number of partitions in the key
cache */
+} PARTITIONED_KEY_CACHE_CB;
static
-void p_end_key_cache(void *keycache_cb, my_bool cleanup);
+void end_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
+ my_bool cleanup);
+
+static int
+reset_partitioned_key_cache_counters(const char *name,
+ PARTITIONED_KEY_CACHE_CB *keycache);
/*
Determine the partition to which the index block to read is ascribed
@@ -5070,11 +5062,12 @@ void p_end_key_cache(void *keycache_cb,
file block is ascribed.
*/
-static
-S_KEY_CACHE_CB *get_key_cache_partition(P_KEY_CACHE_CB *keycache,
- File file, my_off_t filepos)
+static
+SIMPLE_KEY_CACHE_CB *
+get_key_cache_partition(PARTITIONED_KEY_CACHE_CB *keycache,
+ File file, my_off_t filepos)
{
- uint i= KEYCACHE_BASE_EXPR( file, filepos) % keycache->partitions;
+ uint i= KEYCACHE_BASE_EXPR(file, filepos) % keycache->partitions;
return keycache->partition_array[i];
}
@@ -5101,10 +5094,10 @@ S_KEY_CACHE_CB *get_key_cache_partition(
file block is ascribed.
*/
-static
-S_KEY_CACHE_CB *get_key_cache_partition_for_write(P_KEY_CACHE_CB
*keycache,
- File file, my_off_t
filepos,
- ulonglong*
dirty_part_map)
+static SIMPLE_KEY_CACHE_CB
+*get_key_cache_partition_for_write(PARTITIONED_KEY_CACHE_CB *keycache,
+ File file, my_off_t filepos,
+ ulonglong* dirty_part_map)
{
uint i= KEYCACHE_BASE_EXPR( file, filepos) % keycache->partitions;
*dirty_part_map|= 1<<i;
@@ -5116,8 +5109,8 @@ S_KEY_CACHE_CB *get_key_cache_partition_
Initialize a partitioned key cache
SYNOPSIS
- p_init_key_cache()
- keycache_cb pointer to the control block of a partitioned
key cache
+ init_partitioned_key_cache()
+ keycache pointer to the control block of a partitioned
key cache
key_cache_block_size size of blocks to keep cached data
use_mem total memory to use for all key cache partitions
division_limit division limit (may be zero)
@@ -5127,17 +5120,17 @@ S_KEY_CACHE_CB *get_key_cache_partition_
This function is the implementation of the init_key_cache interface
function
that is employed by partitioned key caches.
The function builds and initializes an array of simple key caches,
and then
- initializes the control block structure of the type P_KEY_CACHE_CB
that is
- used for a partitioned key cache. The parameter keycache_cb is
supposed to
- point to this structure. The number of partitions in the
partitioned key
- cache to be built must be passed through the field 'partitions' of this
- structure. The parameter key_cache_block_size specifies the size of
the
- blocks in the the simple key caches to be built. The parameters
- division_limit and age_threshold determine the initial values of those
- characteristics of the simple key caches that are used for midpoint
- insertion strategy. The parameter use_mem specifies the total amount of
- memory to be allocated for the key cache blocks in all simple key
caches
- and for all auxiliary structures.
+ initializes the control block structure of the type
PARTITIONED_KEY_CACHE_CB
+ that is used for a partitioned key cache. The parameter keycache is
+ supposed to point to this structure. The number of partitions in the
+ partitioned key cache to be built must be passed through the field
+ 'partitions' of this structure. The parameter key_cache_block_size
specifies
+ the size of the blocks in the the simple key caches to be built.
+ The parameters division_limit and age_threshold determine the initial
+ values of those characteristics of the simple key caches that are
used for
+ midpoint insertion strategy. The parameter use_mem specifies the total
+ amount of memory to be allocated for the key cache blocks in all
simple key
+ caches and for all auxiliary structures.
RETURN VALUE
total number of blocks in key cache partitions, if successful,
@@ -5152,19 +5145,19 @@ S_KEY_CACHE_CB *get_key_cache_partition_
*/
static
-int p_init_key_cache(void *keycache_cb, uint key_cache_block_size,
- size_t use_mem, uint division_limit,
- uint age_threshold)
+int init_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
+ uint key_cache_block_size,
+ size_t use_mem, uint division_limit,
+ uint age_threshold)
{
int i;
size_t mem_per_cache;
int cnt;
- S_KEY_CACHE_CB *partition;
- S_KEY_CACHE_CB **partition_ptr;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
+ SIMPLE_KEY_CACHE_CB *partition;
+ SIMPLE_KEY_CACHE_CB **partition_ptr;
uint partitions= keycache->partitions;
- int blocks= -1;
- DBUG_ENTER("p_init_key_cache");
+ int blocks= 0;
+ DBUG_ENTER("partitioned_init_key_cache");
keycache->key_cache_block_size = key_cache_block_size;
@@ -5173,9 +5166,9 @@ int p_init_key_cache(void *keycache_cb,
else
{
if(!(partition_ptr=
- (S_KEY_CACHE_CB **) my_malloc(sizeof(S_KEY_CACHE_CB *) * partitions,
- MYF(0))))
- DBUG_RETURN(blocks);
+ (SIMPLE_KEY_CACHE_CB **) my_malloc(sizeof(SIMPLE_KEY_CACHE_CB *) *
+ partitions, MYF(MY_WME))))
+ DBUG_RETURN(-1);
keycache->partition_array= partition_ptr;
}
@@ -5188,36 +5181,35 @@ int p_init_key_cache(void *keycache_cb,
partition= *partition_ptr;
else
{
- if (!(partition= (S_KEY_CACHE_CB *)
my_malloc(sizeof(S_KEY_CACHE_CB),
- MYF(0))))
+ if (!(partition=
+ (SIMPLE_KEY_CACHE_CB *)
my_malloc(sizeof(SIMPLE_KEY_CACHE_CB),
+ MYF(MY_WME))))
continue;
partition->key_cache_inited= 0;
}
- if ((cnt= s_init_key_cache(partition,
- key_cache_block_size, mem_per_cache,
- division_limit, age_threshold)) <= 0)
+ if ((cnt= init_simple_key_cache(partition,
+ key_cache_block_size, mem_per_cache,
+ division_limit, age_threshold)) <= 0)
{
- s_end_key_cache(partition, 1);
- my_free((uchar *) partition, MYF(0));
+ end_simple_key_cache(partition, 1);
+ my_free(partition, MYF(0));
partition= 0;
if (key_cache_inited)
{
memmove(partition_ptr, partition_ptr+1,
sizeof(partition_ptr)*(partitions-i-1));
}
+ if (!--partitions)
+ break;
if (i == 0)
{
i--;
- partitions--;
- if (partitions)
- mem_per_cache = use_mem / partitions;
+ mem_per_cache = use_mem / partitions;
+ continue;
}
- continue;
}
- if (blocks < 0)
- blocks= 0;
blocks+= cnt;
*partition_ptr++= partition;
}
@@ -5229,6 +5221,9 @@ int p_init_key_cache(void *keycache_cb,
keycache->key_cache_inited= 1;
+ if (!partitions)
+ blocks= -1;
+
DBUG_RETURN(blocks);
}
@@ -5237,8 +5232,8 @@ int p_init_key_cache(void *keycache_cb,
Resize a partitioned key cache
SYNOPSIS
- p_resize_key_cache()
- keycache_cb pointer to the control block of a partitioned
key cache
+ resize_partitioned_key_cache()
+ keycache pointer to the control block of a partitioned
key cache
key_cache_block_size size of blocks to keep cached data
use_mem total memory to use for the new key cache
division_limit new division limit (if not zero)
@@ -5247,9 +5242,9 @@ int p_init_key_cache(void *keycache_cb,
DESCRIPTION
This function is the implementation of the resize_key_cache interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for the partitioned
- key cache to be resized.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for the
+ partitioned key cache to be resized.
The parameter key_cache_block_size specifies the new size of the
blocks in
the simple key caches that comprise the partitioned key cache.
The parameters division_limit and age_threshold determine the new
initial
@@ -5263,48 +5258,47 @@ int p_init_key_cache(void *keycache_cb,
0 - otherwise.
NOTES.
- The function first calls s_prepare_resize_key_cache for each simple
+ The function first calls prepare_resize_simple_key_cache for each
simple
key cache effectively flushing all dirty pages from it and destroying
- the key cache. Then p_init_key cache is called. This call builds all
- the new array of simple key caches containing the same number of
- elements as the old one. After this the function calls the function
- s_finish_resize_key_cache for each simple key cache from this array.
+ the key cache. Then init_partitioned_key_cache is called. This call
builds
+ a new array of simple key caches containing the same number of elements
+ as the old one. After this the function calls the function
+ finish_resize_simple_key_cache for each simple key cache from this
array.
This implementation doesn't block the calls and executions of other
functions from the key cache interface. However it assumes that the
- calls of s_resize_key_cache itself are serialized.
-
+ calls of resize_partitioned_key_cache itself are serialized.
*/
static
-int p_resize_key_cache(void *keycache_cb, uint key_cache_block_size,
- size_t use_mem, uint division_limit,
- uint age_threshold)
+int resize_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
+ uint key_cache_block_size,
+ size_t use_mem, uint division_limit,
+ uint age_threshold)
{
uint i;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint partitions= keycache->partitions;
my_bool cleanup= use_mem == 0;
int blocks= -1;
int err= 0;
- DBUG_ENTER("p_resize_key_cache");
- if (use_mem == 0)
+ DBUG_ENTER("partitioned_resize_key_cache");
+ if (cleanup)
{
- p_end_key_cache(keycache_cb, 0);
- DBUG_RETURN(blocks);
+ end_partitioned_key_cache(keycache, 0);
+ DBUG_RETURN(-1);
}
for (i= 0; i < partitions; i++)
{
- err|= s_prepare_resize_key_cache(keycache->partition_array[i], 0, 1);
+ err|= prepare_resize_simple_key_cache(keycache->partition_array[i],
0, 1);
}
- if (!err && use_mem)
- blocks= p_init_key_cache(keycache_cb, key_cache_block_size, use_mem,
- division_limit, age_threshold);
- if (blocks > 0 && !cleanup)
+ if (!err)
+ blocks= init_partitioned_key_cache(keycache, key_cache_block_size,
+ use_mem, division_limit,
age_threshold);
+ if (blocks > 0)
{
for (i= 0; i < partitions; i++)
{
- s_finish_resize_key_cache(keycache->partition_array[i], 0, 1);
+ finish_resize_simple_key_cache(keycache->partition_array[i], 0, 1);
}
}
DBUG_RETURN(blocks);
@@ -5315,17 +5309,17 @@ int p_resize_key_cache(void *keycache_cb
Change key cache parameters of a partitioned key cache
SYNOPSIS
- p_change_key_cache_param()
- keycache_cb pointer to the control block of a partitioned
key cache
+ partitioned_change_key_cache_param()
+ keycache pointer to the control block of a partitioned
key cache
division_limit new division limit (if not zero)
age_threshold new age threshold (if not zero)
DESCRIPTION
This function is the implementation of the change_key_cache_param
interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for the simple key
- cache where new values of the division limit and the age threshold used
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for
the simple
+ key cache where new values of the division limit and the age
threshold used
for midpoint insertion strategy are to be set. The parameters
division_limit and age_threshold provide these new values.
@@ -5333,23 +5327,22 @@ int p_resize_key_cache(void *keycache_cb
none
NOTES
- The function just calls s_change_key_cache_param for each element
from the
- array of simple caches that comprise the partitioned key cache.
-
+ The function just calls change_simple_key_cache_param for each
element from
+ the array of simple caches that comprise the partitioned key cache.
*/
static
-void p_change_key_cache_param(void *keycache_cb, uint division_limit,
- uint age_threshold)
+void change_partitioned_key_cache_param(PARTITIONED_KEY_CACHE_CB *keycache,
+ uint division_limit,
+ uint age_threshold)
{
uint i;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint partitions= keycache->partitions;
- DBUG_ENTER("p_change_key_cache_param");
+ DBUG_ENTER("partitioned_change_key_cache_param");
for (i= 0; i < partitions; i++)
{
- s_change_key_cache_param(keycache->partition_array[i], division_limit,
- age_threshold);
+ change_simple_key_cache_param(keycache->partition_array[i],
division_limit,
+ age_threshold);
}
DBUG_VOID_RETURN;
}
@@ -5359,17 +5352,17 @@ void p_change_key_cache_param(void *keyc
Destroy a partitioned key cache
SYNOPSIS
- p_end_key_cache()
- keycache_cb pointer to the control block of a partitioned
key cache
+ end_partitioned_key_cache()
+ keycache pointer to the control block of a partitioned
key cache
cleanup <=> complete free (free also control block
structures
for all simple key caches)
DESCRIPTION
This function is the implementation of the end_key_cache interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for the partitioned
- key cache to be destroyed.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for the
+ partitioned key cache to be destroyed.
The function frees the memory allocated for the cache blocks and
auxiliary structures used by simple key caches that comprise the
partitioned key cache. If the value of the parameter cleanup is TRUE
@@ -5378,23 +5371,23 @@ void p_change_key_cache_param(void *keyc
RETURN VALUE
none
-
*/
static
-void p_end_key_cache(void *keycache_cb, my_bool cleanup)
+void end_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
+ my_bool cleanup)
{
uint i;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint partitions= keycache->partitions;
- DBUG_ENTER("p_end_key_cache");
+ DBUG_ENTER("partitioned_end_key_cache");
DBUG_PRINT("enter", ("key_cache: 0x%lx", (long) keycache));
for (i= 0; i < partitions; i++)
{
- s_end_key_cache(keycache->partition_array[i], cleanup);
+ end_simple_key_cache(keycache->partition_array[i], cleanup);
}
- if (cleanup) {
+ if (cleanup)
+ {
for (i= 0; i < partitions; i++)
my_free((uchar*) keycache->partition_array[i], MYF(0));
my_free((uchar*) keycache->partition_array, MYF(0));
@@ -5409,8 +5402,8 @@ void p_end_key_cache(void *keycache_cb,
SYNOPSIS
- p_key_cache_read()
- keycache_cb pointer to the control block of a partitioned
key cache
+ partitioned_key_cache_read()
+ keycache pointer to the control block of a partitioned
key cache
file handler for the file for the block of data to
be read
filepos position of the block of data in the file
level determines the weight of the data
@@ -5422,9 +5415,9 @@ void p_end_key_cache(void *keycache_cb,
DESCRIPTION
This function is the implementation of the key_cache_read interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a partitioned
- key cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for a
+ partitioned key cache.
In a general case the function reads a block of data from the key cache
into the buffer buff of the size specified by the parameter length. The
beginning of the block of data to be read is specified by the
parameters
@@ -5432,7 +5425,7 @@ void p_end_key_cache(void *keycache_cb,
of the buffer. The data is read into the buffer in key_cache_block_size
increments. To read each portion the function first finds out in what
partition of the key cache this portion(page) is to be saved, and calls
- s_key_cache_read with the pointer to the corresponding simple key as
+ simple_key_cache_read with the pointer to the corresponding simple
key as
its first parameter.
If the parameter return_buffer is not ignored and its value is
TRUE, and
the data to be read of the specified size block_length can be read
from one
@@ -5445,21 +5438,19 @@ void p_end_key_cache(void *keycache_cb,
RETURN VALUE
Returns address from where the data is placed if successful, 0 -
otherwise.
-
*/
static
-uchar *p_key_cache_read(void *keycache_cb,
- File file, my_off_t filepos, int level,
- uchar *buff, uint length,
- uint block_length __attribute__((unused)),
- int return_buffer __attribute__((unused)))
+uchar *partitioned_key_cache_read(PARTITIONED_KEY_CACHE_CB *keycache,
+ File file, my_off_t filepos, int level,
+ uchar *buff, uint length,
+ uint block_length
__attribute__((unused)),
+ int return_buffer
__attribute__((unused)))
{
uint r_length;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
uchar *start= buff;
- DBUG_ENTER("p_key_cache_read");
+ DBUG_ENTER("partitioned_key_cache_read");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file, (ulong) filepos, length));
@@ -5471,15 +5462,15 @@ uchar *p_key_cache_read(void *keycache_c
/* Read data in key_cache_block_size increments */
do
{
- S_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
- file, filepos);
+ SIMPLE_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
+ file, filepos);
uchar *ret_buff= 0;
r_length= length;
set_if_smaller(r_length, keycache->key_cache_block_size - offset);
- ret_buff= s_key_cache_read((void *) partition,
- file, filepos, level,
- buff, r_length,
- block_length, return_buffer);
+ ret_buff= simple_key_cache_read((void *) partition,
+ file, filepos, level,
+ buff, r_length,
+ block_length, return_buffer);
if (ret_buff == 0)
DBUG_RETURN(0);
#ifndef THREAD
@@ -5500,8 +5491,8 @@ uchar *p_key_cache_read(void *keycache_c
Insert a block of file data from a buffer into a partitioned key cache
SYNOPSIS
- p_key_cache_insert()
- keycache_cb pointer to the control block of a partitioned
key cache
+ partitioned_key_cache_insert()
+ keycache pointer to the control block of a partitioned
key cache
file handler for the file to insert data from
filepos position of the block of data in the file to insert
level determines the weight of the data
@@ -5511,9 +5502,9 @@ uchar *p_key_cache_read(void *keycache_c
DESCRIPTION
This function is the implementation of the key_cache_insert interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a
partitioned key
- cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for a
+ partitioned key cache.
The function writes a block of file data from a buffer into the key
cache.
The buffer is specified with the parameters buff and length - the
pointer
to the beginning of the buffer and its size respectively. It's assumed
@@ -5521,8 +5512,8 @@ uchar *p_key_cache_read(void *keycache_c
filepos. The data is copied from the buffer in key_cache_block_size
increments. For every portion of data the function finds out in
what simple
key cache from the array of partitions the data must be stored, and
after
- this calls s_key_cache_insert to copy the data into a key buffer of
this
- simple key cache.
+ this calls simple_key_cache_insert to copy the data into a key
buffer of
+ this simple key cache.
The parameter level is used to set one characteristic for the key
buffers
loaded with the data from buff. The characteristic is used only by the
midpoint insertion strategy.
@@ -5534,18 +5525,16 @@ uchar *p_key_cache_read(void *keycache_c
The function is used by MyISAM to move all blocks from a index file to
the key cache. It can be performed in parallel with reading the
file data
from the key buffers by other threads.
-
*/
static
-int p_key_cache_insert(void *keycache_cb,
- File file, my_off_t filepos, int level,
- uchar *buff, uint length)
+int partitioned_key_cache_insert(PARTITIONED_KEY_CACHE_CB *keycache,
+ File file, my_off_t filepos, int level,
+ uchar *buff, uint length)
{
uint w_length;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
- DBUG_ENTER("p_key_cache_insert");
+ DBUG_ENTER("partitioned_key_cache_insert");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file,(ulong) filepos, length));
@@ -5553,13 +5542,13 @@ int p_key_cache_insert(void *keycache_cb
/* Write data in key_cache_block_size increments */
do
{
- S_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
- file, filepos);
+ SIMPLE_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
+ file, filepos);
w_length= length;
- set_if_smaller(w_length, keycache->key_cache_block_size);
- if (s_key_cache_insert((void *) partition,
- file, filepos, level,
- buff, w_length))
+ set_if_smaller(w_length, keycache->key_cache_block_size - offset);
+ if (simple_key_cache_insert((void *) partition,
+ file, filepos, level,
+ buff, w_length))
DBUG_RETURN(1);
filepos+= w_length;
@@ -5576,8 +5565,8 @@ int p_key_cache_insert(void *keycache_cb
SYNOPSIS
- p_key_cache_write()
- keycache_cb pointer to the control block of a partitioned
key cache
+ partitioned_key_cache_write()
+ keycache pointer to the control block of a partitioned
key cache
file handler for the file to write data to
filepos position in the file to write data to
level determines the weight of the data
@@ -5591,9 +5580,9 @@ int p_key_cache_insert(void *keycache_cb
DESCRIPTION
This function is the implementation of the key_cache_write interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a partitioned
- key cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for a
+ partitioned key cache.
In a general case the function copies data from a buffer into the key
cache. The buffer is specified with the parameters buff and length -
the pointer to the beginning of the buffer and its size respectively.
@@ -5601,8 +5590,8 @@ int p_key_cache_insert(void *keycache_cb
starting from the position filepos. The data is copied from the buffer
in key_cache_block_size increments. For every portion of data the
function finds out in what simple key cache from the array of
partitions
- the data must be stored, and after this calls s_key_cache_write to copy
- the data into a key buffer of this simple key cache.
+ the data must be stored, and after this calls simple_key_cache_write to
+ copy the data into a key buffer of this simple key cache.
If the value of the parameter dont_write is FALSE then the function
also writes the data into file.
The parameter level is used to set one characteristic for the key
buffers
@@ -5610,7 +5599,7 @@ int p_key_cache_insert(void *keycache_cb
the midpoint insertion strategy.
The parameter file_expra provides a pointer to the shared bitmap of
the partitions that may contains dirty pages for the file. This bitmap
- is used to optimize the function p_flush_key_blocks.
+ is used to optimize the function flush_partitioned_key_cache_blocks.
RETURN VALUE
0 if a success, 1 - otherwise.
@@ -5618,22 +5607,20 @@ int p_key_cache_insert(void *keycache_cb
NOTES
This implementation exploits the fact that the function is called only
when a thread has got an exclusive lock for the key file.
-
*/
static
-int p_key_cache_write(void *keycache_cb,
- File file, void *file_extra,
- my_off_t filepos, int level,
- uchar *buff, uint length,
- uint block_length __attribute__((unused)),
- int dont_write)
+int partitioned_key_cache_write(PARTITIONED_KEY_CACHE_CB *keycache,
+ File file, void *file_extra,
+ my_off_t filepos, int level,
+ uchar *buff, uint length,
+ uint block_length __attribute__((unused)),
+ int dont_write)
{
uint w_length;
ulonglong *part_map= (ulonglong *) file_extra;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
- DBUG_ENTER("p_key_cache_write");
+ DBUG_ENTER("partitioned_key_cache_write");
DBUG_PRINT("enter",
("fd: %u pos: %lu length: %u block_length: %u"
" key_block_length: %u",
@@ -5644,15 +5631,16 @@ int p_key_cache_write(void *keycache_cb,
/* Write data in key_cache_block_size increments */
do
{
- S_KEY_CACHE_CB *partition= get_key_cache_partition_for_write(keycache,
- file,
filepos,
- part_map);
+ SIMPLE_KEY_CACHE_CB *partition=
get_key_cache_partition_for_write(keycache,
+ file,
+
filepos,
+
part_map);
w_length = length;
- set_if_smaller(w_length, keycache->key_cache_block_size );
- if (s_key_cache_write(partition,
- file, 0, filepos, level,
- buff, w_length, block_length,
- dont_write))
+ set_if_smaller(w_length, keycache->key_cache_block_size - offset );
+ if (simple_key_cache_write(partition,
+ file, 0, filepos, level,
+ buff, w_length, block_length,
+ dont_write))
DBUG_RETURN(1);
filepos+= w_length;
@@ -5669,8 +5657,8 @@ int p_key_cache_write(void *keycache_cb,
SYNOPSIS
- p_flush_key_blocks()
- keycache_cb pointer to the control block of a partitioned
key cache
+ flush_partitioned_key_cache_blocks()
+ keycache pointer to the control block of a partitioned
key cache
file handler for the file to flush to
file_extra maps of key cache partitions containing
dirty pages from file (not used)
@@ -5679,9 +5667,9 @@ int p_key_cache_write(void *keycache_cb,
DESCRIPTION
This function is the implementation of the flush_key_blocks interface
function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a partitioned
- key cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for a
+ partitioned key cache.
In a general case the function flushes the data from all dirty key
buffers related to the file 'file' into this file. The function does
exactly this if the value of the parameter type is FLUSH_KEEP. If the
@@ -5689,12 +5677,12 @@ int p_key_cache_write(void *keycache_cb,
releases the key buffers containing data from 'file' for new usage.
If the value of the parameter type is FLUSH_IGNORE_CHANGED the function
just releases the key buffers containing data from 'file'.
- The function performs the operation by calling s_flush_key_blocks
- for the elements of the array of the simple key caches that comprise
- the partitioned key_cache. If the value of the parameter type is
- FLUSH_KEEP s_flush_key_blocks is called only for the partitions with
- possibly dirty pages marked in the bitmap pointed to by the parameter
- file_extra.
+ The function performs the operation by calling the function
+ flush_simple_key_cache_blocks for the elements of the array of the
+ simple key caches that comprise the partitioned key_cache. If the value
+ of the parameter type is FLUSH_KEEP s_flush_key_blocks is called only
+ for the partitions with possibly dirty pages marked in the bitmap
+ pointed to by the parameter file_extra.
RETURN
0 ok
@@ -5703,35 +5691,30 @@ int p_key_cache_write(void *keycache_cb,
NOTES
This implementation exploits the fact that the function is called only
when a thread has got an exclusive lock for the key file.
-
*/
static
-int p_flush_key_blocks(void *keycache_cb,
- File file, void *file_extra,
- enum flush_type type)
+int flush_partitioned_key_cache_blocks(PARTITIONED_KEY_CACHE_CB *keycache,
+ File file, void *file_extra,
+ enum flush_type type)
{
uint i;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint partitions= keycache->partitions;
int err= 0;
ulonglong *dirty_part_map= (ulonglong *) file_extra;
- DBUG_ENTER("p_flush_key_blocks");
+ DBUG_ENTER("partitioned_flush_key_blocks");
DBUG_PRINT("enter", ("keycache: 0x%lx", (long) keycache));
for (i= 0; i < partitions; i++)
{
- S_KEY_CACHE_CB *partition= keycache->partition_array[i];
+ SIMPLE_KEY_CACHE_CB *partition= keycache->partition_array[i];
if ((type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE) &&
- !((*dirty_part_map) & (1<<i)))
+ !((*dirty_part_map) & ((ulonglong) 1 << i)))
continue;
- err+= test(s_flush_key_blocks(partition, file, 0, type));
+ err|= test(flush_simple_key_cache_blocks(partition, file, 0, type));
}
*dirty_part_map= 0;
- if (err > 0)
- err= 1;
-
DBUG_RETURN(err);
}
@@ -5740,38 +5723,36 @@ int p_flush_key_blocks(void *keycache_cb
Reset the counters of a partitioned key cache
SYNOPSIS
- p_reset_key_cache_counters()
+ reset_partitioned_key_cache_counters()
name the name of a key cache
- keycache_cb pointer to the control block of a partitioned
key cache
+ keycache pointer to the control block of a partitioned
key cache
DESCRIPTION
This function is the implementation of the reset_key_cache_counters
interface function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a partitioned
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for a
partitioned
key cache.
This function resets the values of the statistical counters of the
simple
key caches comprising partitioned key cache to 0. It does it by
calling
- s_reset_key_cache_counters for each key cache partition.
+ reset_simple_key_cache_counters for each key cache partition.
The parameter name is currently not used.
RETURN
0 on success (always because it can't fail)
-
*/
-static
-int p_reset_key_cache_counters(const char *name __attribute__((unused)),
- void *keycache_cb)
+static int
+reset_partitioned_key_cache_counters(const char *name
__attribute__((unused)),
+ PARTITIONED_KEY_CACHE_CB *keycache)
{
uint i;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint partitions= keycache->partitions;
- DBUG_ENTER("p_reset_key_cache_counters");
+ DBUG_ENTER("partitioned_reset_key_cache_counters");
for (i = 0; i < partitions; i++)
{
- s_reset_key_cache_counters(name, keycache->partition_array[i]);
+ reset_simple_key_cache_counters(name, keycache->partition_array[i]);
}
DBUG_RETURN(0);
}
@@ -5781,17 +5762,17 @@ int p_reset_key_cache_counters(const cha
Get statistics for a partition key cache
SYNOPSIS
- p_get_key_cache_statistics()
- keycache_cb pointer to the control block of a partitioned
key cache
+ get_partitioned_key_cache_statistics()
+ keycache pointer to the control block of a partitioned
key cache
partition_no partition number to get statistics for
key_cache_stats OUT pointer to the structure for the returned
statistics
DESCRIPTION
This function is the implementation of the get_key_cache_statistics
interface function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a partitioned
- key cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for
+ a partitioned key cache.
If the value of the parameter partition_no is equal to 0 then
aggregated
statistics for all partitions is returned in the fields of the
structure key_cache_stat of the type KEY_CACHE_STATISTICS . Otherwise
@@ -5801,37 +5782,38 @@ int p_reset_key_cache_counters(const cha
RETURN
none
-
*/
static
-void p_get_key_cache_statistics(void *keycache_cb, uint partition_no,
- KEY_CACHE_STATISTICS *key_cache_stats)
+void
+get_partitioned_key_cache_statistics(PARTITIONED_KEY_CACHE_CB *keycache,
+ uint partition_no,
+ KEY_CACHE_STATISTICS *keycache_stats)
{
uint i;
- S_KEY_CACHE_CB *partition;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
+ SIMPLE_KEY_CACHE_CB *partition;
uint partitions= keycache->partitions;
- DBUG_ENTER("p_get_key_cache_statistics_");
+ DBUG_ENTER("get_partitioned_key_cache_statistics");
if (partition_no != 0)
{
partition= keycache->partition_array[partition_no-1];
- s_get_key_cache_statistics((void *) partition, 0, key_cache_stats);
+ get_simple_key_cache_statistics((void *) partition, 0, keycache_stats);
DBUG_VOID_RETURN;
}
- key_cache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
- key_cache_stats->block_size= (longlong) keycache->key_cache_block_size;
+ bzero(keycache_stats, sizeof(KEY_CACHE_STATISTICS));
+ keycache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
+ keycache_stats->block_size= (longlong) keycache->key_cache_block_size;
for (i = 0; i < partitions; i++)
{
partition= keycache->partition_array[i];
- key_cache_stats->blocks_used+= partition->blocks_used;
- key_cache_stats->blocks_unused+= partition->blocks_unused;
- key_cache_stats->blocks_changed+= partition->global_blocks_changed;
- key_cache_stats->read_requests+= partition->global_cache_r_requests;
- key_cache_stats->reads+= partition->global_cache_read;
- key_cache_stats->write_requests+= partition->global_cache_w_requests;
- key_cache_stats->writes+= partition->global_cache_write;
+ keycache_stats->blocks_used+= partition->blocks_used;
+ keycache_stats->blocks_unused+= partition->blocks_unused;
+ keycache_stats->blocks_changed+= partition->global_blocks_changed;
+ keycache_stats->read_requests+= partition->global_cache_r_requests;
+ keycache_stats->reads+= partition->global_cache_read;
+ keycache_stats->write_requests+= partition->global_cache_w_requests;
+ keycache_stats->writes+= partition->global_cache_write;
}
DBUG_VOID_RETURN;
}
@@ -5840,16 +5822,16 @@ void p_get_key_cache_statistics(void *ke
Get the value of a statistical variable for a partitioned key cache
SYNOPSIS
- p_get_key_cache_stat_value()
- keycache_cb pointer to the control block of a partitioned
key cache
+ get_partitioned_key_cache_stat_value()
+ keycache pointer to the control block of a partitioned
key cache
var_no the ordered number of a statistical variable
DESCRIPTION
This function is the implementation of the get_key_cache_stat_value
interface function that is employed by partitioned key caches.
- The function considers the parameter keycache_cb as a pointer to the
- control block structure of the type P_KEY_CACHE_CB for a partitioned
- key cache.
+ The function takes the parameter keycache as a pointer to the
+ control block structure of the type PARTITIONED_KEY_CACHE_CB for a
+ partitioned key cache.
This function returns the value of the statistical variable var_no
for this key cache. The variables are numbered starting from 0 to 6.
The returned value is calculated as the sum of the values of the
@@ -5858,24 +5840,24 @@ void p_get_key_cache_statistics(void *ke
RETURN
The value of the specified statistical variable
-
*/
static
-ulonglong p_get_key_cache_stat_value(void *keycache_cb, uint var_no)
+ulonglong
+get_partitioned_key_cache_stat_value(PARTITIONED_KEY_CACHE_CB *keycache,
+ uint var_no)
{
uint i;
- P_KEY_CACHE_CB *keycache= (P_KEY_CACHE_CB *) keycache_cb;
uint partitions= keycache->partitions;
- size_t var_ofs= s_key_cache_stat_var_offsets[var_no];
+ size_t var_ofs= simple_key_cache_stat_var_offsets[var_no];
ulonglong res= 0;
- DBUG_ENTER("p_get_key_cache_stat_value");
+ DBUG_ENTER("get_partitioned_key_cache_stat_value");
- if (var_no < 3)
+ if (var_no < NO_LONG_KEY_CACHE_STAT_VARIABLES)
{
for (i = 0; i < partitions; i++)
{
- S_KEY_CACHE_CB *partition= keycache->partition_array[i];
+ SIMPLE_KEY_CACHE_CB *partition= keycache->partition_array[i];
res+= (ulonglong) (*(long *) ((char *) partition + var_ofs));
}
}
@@ -5883,7 +5865,7 @@ ulonglong p_get_key_cache_stat_value(voi
{
for (i = 0; i < partitions; i++)
{
- S_KEY_CACHE_CB *partition= keycache->partition_array[i];
+ SIMPLE_KEY_CACHE_CB *partition= keycache->partition_array[i];
res+= *(ulonglong *) ((char *) partition + var_ofs);
}
}
@@ -5901,19 +5883,19 @@ ulonglong p_get_key_cache_stat_value(voi
wrappers must be used for this purpose.
*/
-static KEY_CACHE_FUNCS p_key_cache_funcs =
+static KEY_CACHE_FUNCS partitioned_key_cache_funcs =
{
- p_init_key_cache,
- p_resize_key_cache,
- p_change_key_cache_param,
- p_key_cache_read,
- p_key_cache_insert,
- p_key_cache_write,
- p_flush_key_blocks,
- p_reset_key_cache_counters,
- p_end_key_cache,
- p_get_key_cache_statistics,
- p_get_key_cache_stat_value
+ (INIT_KEY_CACHE) init_partitioned_key_cache,
+ (RESIZE_KEY_CACHE) resize_partitioned_key_cache,
+ (CHANGE_KEY_CACHE_PARAM) change_partitioned_key_cache_param,
+ (KEY_CACHE_READ) partitioned_key_cache_read,
+ (KEY_CACHE_INSERT) partitioned_key_cache_insert,
+ (KEY_CACHE_WRITE) partitioned_key_cache_write,
+ (FLUSH_KEY_BLOCKS) flush_partitioned_key_cache_blocks,
+ (RESET_KEY_CACHE_COUNTERS) reset_partitioned_key_cache_counters,
+ (END_KEY_CACHE) end_partitioned_key_cache,
+ (GET_KEY_CACHE_STATISTICS) get_partitioned_key_cache_statistics,
+ (GET_KEY_CACHE_STAT_VALUE) get_partitioned_key_cache_stat_value
};
@@ -5926,12 +5908,12 @@ static KEY_CACHE_FUNCS p_key_cache_funcs
partitioned key caches. Each type (class) has its own implementation
of the
basic key cache operations used the MyISAM storage engine. The pointers
to the implementation functions are stored in two static structures
of the
- type KEY_CACHE_FUNC: s_key_cache_funcs - for simple key caches, and
- p_key_cache_funcs - for partitioned key caches. When a key cache
object is
- created the constructor procedure init_key_cache places a pointer to the
- corresponding table into one of its fields. The procedure also
initializes
- a control block for the key cache oject and saves the pointer to this
- block in another field of the key cache object.
+ type KEY_CACHE_FUNC: simple_key_cache_funcs - for simple key caches, and
+ partitioned_key_cache_funcs - for partitioned key caches. When a key
cache
+ object is created the constructor procedure init_key_cache places a
pointer
+ to the corresponding table into one of its fields. The procedure also
+ initializes a control block for the key cache oject and saves the pointer
+ to this block in another field of the key cache object.
When a key cache wrapper function is invoked for a key cache object to
perform a basic key cache operation it looks into the interface table
associated with the key cache oject and calls the corresponding
@@ -5982,7 +5964,6 @@ static KEY_CACHE_FUNCS p_key_cache_funcs
It's assumed that no two threads call this function simultaneously
referring to the same key cache handle.
-
*/
int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
@@ -5997,19 +5978,21 @@ int init_key_cache(KEY_CACHE *keycache,
{
if (partitions == 0)
{
- if (!(keycache_cb= (void *) my_malloc(sizeof(S_KEY_CACHE_CB),
MYF(0))))
+ if (!(keycache_cb= (void *) my_malloc(sizeof(SIMPLE_KEY_CACHE_CB),
+ MYF(0))))
return 0;
- ((S_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
+ ((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= SIMPLE_KEY_CACHE;
- keycache->interface_funcs= &s_key_cache_funcs;
+ keycache->interface_funcs= &simple_key_cache_funcs;
}
else
{
- if (!(keycache_cb= (void *) my_malloc(sizeof(P_KEY_CACHE_CB),
MYF(0))))
+ if (!(keycache_cb= (void *)
my_malloc(sizeof(PARTITIONED_KEY_CACHE_CB),
+ MYF(0))))
return 0;
- ((P_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
+ ((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= PARTITIONED_KEY_CACHE;
- keycache->interface_funcs= &p_key_cache_funcs;
+ keycache->interface_funcs= &partitioned_key_cache_funcs;
}
keycache->keycache_cb= keycache_cb;
keycache->key_cache_inited= 1;
@@ -6017,14 +6000,15 @@ int init_key_cache(KEY_CACHE *keycache,
if (partitions != 0)
{
- ((P_KEY_CACHE_CB *) keycache_cb)->partitions= partitions;
+ ((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions= partitions;
}
keycache->can_be_used= 0;
blocks= keycache->interface_funcs->init(keycache_cb,
key_cache_block_size,
use_mem, division_limit,
age_threshold);
keycache->partitions= partitions ?
- ((P_KEY_CACHE_CB *) keycache_cb)->partitions : 0;
+ ((PARTITIONED_KEY_CACHE_CB *)
keycache_cb)->partitions :
+ 0;
DBUG_ASSERT(partitions <= MAX_KEY_CACHE_PARTITIONS);
if (blocks > 0)
keycache->can_be_used= 1;
@@ -6037,7 +6021,7 @@ int init_key_cache(KEY_CACHE *keycache,
SYNOPSIS
resize_key_cache()
- keycache pointer to the key cache to be resized
+ keycache pointer to the key cache to be resized
key_cache_block_size size of blocks to keep cached data
use_mem total memory to use for the new key cache
division_limit new division limit (if not zero)
@@ -6064,7 +6048,6 @@ int init_key_cache(KEY_CACHE *keycache,
Currently the function is called when the values of the variables
key_buffer_size and/or key_cache_block_size are being reset for
the key cache keycache.
-
*/
int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
@@ -6074,10 +6057,10 @@ int resize_key_cache(KEY_CACHE *keycache
if (keycache->key_cache_inited)
{
if ((uint) keycache->param_partitions != keycache->partitions &&
use_mem)
- blocks= repartition_key_cache (keycache,
- key_cache_block_size, use_mem,
- division_limit, age_threshold,
- (uint) keycache->param_partitions);
+ blocks= repartition_key_cache(keycache,
+ key_cache_block_size, use_mem,
+ division_limit, age_threshold,
+ (uint) keycache->param_partitions);
else
{
blocks= keycache->interface_funcs->resize(keycache->keycache_cb,
@@ -6087,10 +6070,10 @@ int resize_key_cache(KEY_CACHE *keycache
if (keycache->partitions)
keycache->partitions=
- ((P_KEY_CACHE_CB *)(keycache->keycache_cb))->partitions;
+ ((PARTITIONED_KEY_CACHE_CB
*)(keycache->keycache_cb))->partitions;
}
- if (blocks <= 0)
- keycache->can_be_used= 0;
+
+ keycache->can_be_used= (blocks >= 0);
}
return blocks;
}
@@ -6117,7 +6100,6 @@ int resize_key_cache(KEY_CACHE *keycache
Currently the function is called when the values of the variables
key_cache_division_limit and/or key_cache_age_threshold are being reset
for the key cache keycache.
-
*/
void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
@@ -6262,7 +6244,6 @@ uchar *key_cache_read(KEY_CACHE *keycach
the key cache.
It is assumed that it may be performed in parallel with reading the
file
data from the key buffers by other threads.
-
*/
int key_cache_insert(KEY_CACHE *keycache,
@@ -6316,7 +6297,6 @@ int key_cache_insert(KEY_CACHE *keycache
NOTES
This implementation may exploit the fact that the function is
called only
when a thread has got an exclusive lock for the key file.
-
*/
int key_cache_write(KEY_CACHE *keycache,
@@ -6373,7 +6353,6 @@ int key_cache_write(KEY_CACHE *keycache,
NOTES
Any implementation of the function may exploit the fact that the
function
is called only when a thread has got an exclusive lock for the key
file.
-
*/
int flush_key_blocks(KEY_CACHE *keycache,
@@ -6406,7 +6385,6 @@ int flush_key_blocks(KEY_CACHE *keycache
NOTES
This procedure is used by process_key_caches() to reset the counters
of all
currently used key caches, both the default one and the named ones.
-
*/
int reset_key_cache_counters(const char *name __attribute__((unused)),
@@ -6441,13 +6419,11 @@ int reset_key_cache_counters(const char
RETURN
none
-
*/
void get_key_cache_statistics(KEY_CACHE *keycache, uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats)
{
- bzero(key_cache_stats, sizeof(KEY_CACHE_STATISTICS));
if (keycache->key_cache_inited)
{
keycache->interface_funcs->get_stats(keycache->keycache_cb,
@@ -6484,7 +6460,6 @@ void get_key_cache_statistics(KEY_CACHE
reads 4
write_requests 5
writes 6
-
*/
ulonglong get_key_cache_stat_value(KEY_CACHE *keycache, uint var_no)
@@ -6534,7 +6509,6 @@ ulonglong get_key_cache_stat_value(KEY_C
Currently the function is called when the value of the variable
key_cache_partitions is being reset for the key cache keycache.
-
*/
int repartition_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
=== modified file 'sql/sql_show.cc'
--- a/sql/sql_show.cc 2010-03-29 21:16:12 +0000
+++ b/sql/sql_show.cc 2010-04-01 21:42:40 +0000
@@ -2235,8 +2235,9 @@ static void update_key_cache_stat_var(KE
case offsetof(KEY_CACHE, global_cache_read):
case offsetof(KEY_CACHE, global_cache_w_requests):
case offsetof(KEY_CACHE, global_cache_write):
- var_no= 3+(ofs-offsetof(KEY_CACHE, global_cache_w_requests))/
- sizeof(ulonglong);
+ var_no= NO_LONG_KEY_CACHE_STAT_VARIABLES +
+ (ofs-offsetof(KEY_CACHE, global_cache_w_requests))/
+ sizeof(ulonglong);
*(ulonglong *)((char *) key_cache + ofs)=
get_key_cache_stat_value(key_cache, var_no);
break;
@@ -6643,13 +6644,13 @@ int store_key_cache_table_record(THD *th
KEY_CACHE *key_cache,
uint partitions, uint partition_no)
{
- KEY_CACHE_STATISTICS key_cache_stats;
+ KEY_CACHE_STATISTICS keycache_stats;
uint err;
DBUG_ENTER("store_key_cache_table_record");
- get_key_cache_statistics(key_cache, partition_no, &key_cache_stats);
+ get_key_cache_statistics(key_cache, partition_no, &keycache_stats);
- if (key_cache_stats.mem_size == 0)
+ if (!key_cache->key_cache_inited || keycache_stats.mem_size == 0)
DBUG_RETURN(0);
restore_record(table, s->default_values);
@@ -6669,15 +6670,15 @@ int store_key_cache_table_record(THD *th
table->field[2]->set_notnull();
table->field[2]->store((long) partition_no, TRUE);
}
- table->field[3]->store(key_cache_stats.mem_size, TRUE);
- table->field[4]->store(key_cache_stats.block_size, TRUE);
- table->field[5]->store(key_cache_stats.blocks_used, TRUE);
- table->field[6]->store(key_cache_stats.blocks_unused, TRUE);
- table->field[7]->store(key_cache_stats.blocks_changed, TRUE);
- table->field[8]->store(key_cache_stats.read_requests, TRUE);
- table->field[9]->store(key_cache_stats.reads, TRUE);
- table->field[10]->store(key_cache_stats.write_requests, TRUE);
- table->field[11]->store(key_cache_stats.writes, TRUE);
+ table->field[3]->store(keycache_stats.mem_size, TRUE);
+ table->field[4]->store(keycache_stats.block_size, TRUE);
+ table->field[5]->store(keycache_stats.blocks_used, TRUE);
+ table->field[6]->store(keycache_stats.blocks_unused, TRUE);
+ table->field[7]->store(keycache_stats.blocks_changed, TRUE);
+ table->field[8]->store(keycache_stats.read_requests, TRUE);
+ table->field[9]->store(keycache_stats.reads, TRUE);
+ table->field[10]->store(keycache_stats.write_requests, TRUE);
+ table->field[11]->store(keycache_stats.writes, TRUE);
err= schema_table_store_record(thd, table);
DBUG_RETURN(err);
_______________________________________________
Mailing list: https://launchpad.net/~maria-developers
Post to : maria-developers@xxxxxxxxxxxxxxxxxxx
Unsubscribe : https://launchpad.net/~maria-developers
More help : https://help.launchpad.net/ListHelp
Follow ups
References
