Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

sane implementation of Key_% status variables.

pull/843/head
Sergei Golubchik 15 years ago
parent
7c24e8d54d
commit
716f784375
7 changed files with 59 additions and 229 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      include/keycache.h
  2. 159
      mysys/mf_keycache.c
  3. 3
      sql/mysql_priv.h
  4. 47
      sql/mysqld.cc
  5. 38
      sql/sql_show.cc
  6. 14
      sql/sql_test.cc
  7. 15
      storage/myisam/mi_test2.c

12
include/keycache.h
View File

@ -107,9 +107,6 @@ 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
@ -134,7 +131,6 @@ typedef struct st_key_cache_funcs
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;
@ -153,13 +149,6 @@ typedef struct st_key_cache
my_bool in_init; /* Set to 1 in MySQL during init/resize */
uint partitions; /* actual number of partitions */
size_t key_cache_mem_size; /* specified size of the cache memory */
ulong blocks_used; /* maximum number of concurrently used blocks */
ulong blocks_unused; /* number of currently unused blocks */
ulong global_blocks_changed; /* number of currently dirty blocks */
ulonglong global_cache_w_requests;/* number of write requests (write hits) */
ulonglong global_cache_write; /* number of writes from cache to files */
ulonglong global_cache_r_requests;/* number of read requests (read hits) */
ulonglong global_cache_read; /* number of reads from files to cache */
} KEY_CACHE;
@ -193,7 +182,6 @@ extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
extern void get_key_cache_statistics(KEY_CACHE *keycache,
uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats);
extern ulonglong get_key_cache_stat_value(KEY_CACHE *keycache, uint var_no);
/* Functions to handle multiple key caches */
extern my_bool multi_keycache_init(void);

159
mysys/mf_keycache.c
View File

@ -4914,61 +4914,6 @@ void get_simple_key_cache_statistics(SIMPLE_KEY_CACHE_CB *keycache,
}
/*
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(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)
};
/*
Get the value of a statistical variable for a simple key cache
SYNOPSIS
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 get_simple_key_cache_stat_value
interface function that is employed by simple (non-partitioned) key caches.
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
The value of the specified statistical variable
*/
static
ulonglong get_simple_key_cache_stat_value(SIMPLE_KEY_CACHE_CB *keycache,
uint var_no)
{
size_t var_ofs= simple_key_cache_stat_var_offsets[var_no];
ulonglong res= 0;
DBUG_ENTER("get_simple_key_cache_stat_value");
if (var_no < 3)
res= (ulonglong) (*(long *) ((char *) keycache + var_ofs));
else
res= *(ulonglong *) ((char *) keycache + var_ofs);
DBUG_RETURN(res);
}
/*
The array of pointer to the key cache interface functions used for simple
key caches. Any simple key cache objects including those incorporated into
@ -4990,7 +4935,6 @@ static KEY_CACHE_FUNCS simple_key_cache_funcs =
(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
};
@ -5861,61 +5805,6 @@ get_partitioned_key_cache_statistics(PARTITIONED_KEY_CACHE_CB *keycache,
DBUG_VOID_RETURN;
}
/*
Get the value of a statistical variable for a partitioned key cache
SYNOPSIS
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 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
statistical variable with number var_no for all simple key caches that
comprise the partitioned key cache.
RETURN
The value of the specified statistical variable
*/
static
ulonglong
get_partitioned_key_cache_stat_value(PARTITIONED_KEY_CACHE_CB *keycache,
uint var_no)
{
uint i;
uint partitions= keycache->partitions;
size_t var_ofs= simple_key_cache_stat_var_offsets[var_no];
ulonglong res= 0;
DBUG_ENTER("get_partitioned_key_cache_stat_value");
if (var_no < NUM_LONG_KEY_CACHE_STAT_VARIABLES)
{
for (i = 0; i < partitions; i++)
{
SIMPLE_KEY_CACHE_CB *partition= keycache->partition_array[i];
res+= (ulonglong) (*(long *) ((char *) partition + var_ofs));
}
}
else
{
for (i = 0; i < partitions; i++)
{
SIMPLE_KEY_CACHE_CB *partition= keycache->partition_array[i];
res+= *(ulonglong *) ((char *) partition + var_ofs);
}
}
DBUG_RETURN(res);
}
/*
The array of pointers to the key cache interface functions used by
partitioned key caches. Any partitioned key cache object caches exploits
@ -5938,7 +5827,6 @@ static KEY_CACHE_FUNCS partitioned_key_cache_funcs =
(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
};
@ -6246,8 +6134,6 @@ uchar *key_cache_read(KEY_CACHE *keycache,
block_length, return_buffer);
/* We can't use mutex here as the key cache may not be initialized */
keycache->global_cache_r_requests++;
keycache->global_cache_read++;
if (my_pread(file, (uchar*) buff, length, filepos, MYF(MY_NABP)))
return (uchar *) 0;
@ -6356,8 +6242,6 @@ int key_cache_write(KEY_CACHE *keycache,
block_length, force_write);
/* We can't use mutex here as the key cache may not be initialized */
keycache->global_cache_w_requests++;
keycache->global_cache_write++;
if (my_pwrite(file, buff, length, filepos, MYF(MY_NABP | MY_WAIT_IF_FULL)))
return 1;
@ -6474,49 +6358,6 @@ void get_key_cache_statistics(KEY_CACHE *keycache, uint partition_no,
}
}
/*
Get the value of a statistical variable for a key cache
SYNOPSIS
get_key_cache_stat_value()
keycache pointer to the key cache to get statistics for
var_no the ordered number of a statistical variable
DESCRIPTION
This function returns the value of the statistical variable var_no for
the key cache keycache. The variables are numbered starting from 0 to 6.
RETURN
The value of the specified statistical variable.
NOTES
Currently for any key cache the function can return values for the
following 7 statistical variables:
Name Number
blocks_used 0
blocks_unused 1
blocks_changed 2
read_requests 3
reads 4
write_requests 5
writes 6
*/
ulonglong get_key_cache_stat_value(KEY_CACHE *keycache, uint var_no)
{
if (keycache->key_cache_inited)
{
return keycache->interface_funcs->get_stat_val(keycache->keycache_cb,
var_no);
}
else
return 0;
}
/*
Repartition a key cache

3
sql/mysql_priv.h
View File

@ -33,8 +33,7 @@
that is defined in mysql/plugin.h
it has to be before mysql/plugin.h is included.
*/
#define SHOW_always_last SHOW_KEY_CACHE_LONG, \
SHOW_KEY_CACHE_LONGLONG, SHOW_LONG_STATUS, SHOW_DOUBLE_STATUS, \
#define SHOW_always_last SHOW_LONG_STATUS, SHOW_DOUBLE_STATUS, \
SHOW_HAVE, SHOW_MY_BOOL, SHOW_HA_ROWS, SHOW_SYS, \
SHOW_LONG_NOFLUSH, SHOW_LONGLONG_STATUS

47
sql/mysqld.cc
View File

@ -7948,6 +7948,45 @@ static int show_ssl_get_cipher_list(THD *thd, SHOW_VAR *var, char *buff)
#endif /* HAVE_OPENSSL */
static int show_default_keycache(THD *thd, SHOW_VAR *var, char *buff)
{
struct st_data {
KEY_CACHE_STATISTICS stats;
SHOW_VAR var[8];
} *data;
SHOW_VAR *v;
data=(st_data *)buff;
v= data->var;
var->type= SHOW_ARRAY;
var->value= (char*)v;
get_key_cache_statistics(dflt_key_cache, 0, &data->stats);
#define set_one_keycache_var(X,Y) \
v->name= X; \
v->type= SHOW_LONGLONG; \
v->value= (char*)&data->stats.Y; \
v++;
set_one_keycache_var("blocks_not_flushed", blocks_changed);
set_one_keycache_var("blocks_unused", blocks_unused);
set_one_keycache_var("blocks_used", blocks_used);
set_one_keycache_var("read_requests", read_requests);
set_one_keycache_var("reads", reads);
set_one_keycache_var("write_requests", write_requests);
set_one_keycache_var("writes", writes);
v->name= 0;
DBUG_ASSERT((char*)(v+1) <= buff + SHOW_VAR_FUNC_BUFF_SIZE);
#undef set_one_keycache_var
return 0;
}
/*
Variables shown by SHOW STATUS in alphabetical order
@ -7990,13 +8029,7 @@ SHOW_VAR status_vars[]= {
{"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},
{"Handler_update", (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},
{"Handler_write", (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},
{"Key_blocks_not_flushed", (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},
{"Key_blocks_unused", (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},
{"Key_blocks_used", (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},
{"Key_read_requests", (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},
{"Key_reads", (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},
{"Key_write_requests", (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},
{"Key_writes", (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},
{"Key", (char*) &show_default_keycache, SHOW_FUNC},
{"Last_query_cost", (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},
{"Max_used_connections", (char*) &max_used_connections, SHOW_LONG},
{"Not_flushed_delayed_rows", (char*) &delayed_rows_in_use, SHOW_LONG_NOFLUSH},

38
sql/sql_show.cc
View File

@ -2292,34 +2292,6 @@ void remove_status_vars(SHOW_VAR *list)
static void update_key_cache_stat_var(KEY_CACHE *key_cache, size_t ofs)
{
uint var_no;
if (ofs == offsetof(KEY_CACHE, blocks_used) ||
ofs == offsetof(KEY_CACHE, blocks_unused) ||
ofs == offsetof(KEY_CACHE, global_blocks_changed))
{
var_no= (ofs-offsetof(KEY_CACHE, blocks_used))/sizeof(ulong);
*(ulong *)((char *) key_cache + ofs)=
(ulong) get_key_cache_stat_value(key_cache, var_no);
return;
}
if (ofs == offsetof(KEY_CACHE, global_cache_r_requests) ||
ofs == offsetof(KEY_CACHE, global_cache_read) ||
ofs == offsetof(KEY_CACHE, global_cache_w_requests) ||
ofs == offsetof(KEY_CACHE, global_cache_write))
{
var_no= NUM_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);
return;
}
}
static bool show_status_array(THD *thd, const char *wild,
SHOW_VAR *variables,
enum enum_var_type value_type,
@ -2451,16 +2423,6 @@ static bool show_status_array(THD *thd, const char *wild,
end= strend(pos);
break;
}
case SHOW_KEY_CACHE_LONG:
update_key_cache_stat_var(dflt_key_cache, (size_t) value);
value= (char*) dflt_key_cache + (ulong)value;
end= int10_to_str(*(long*) value, buff, 10);
break;
case SHOW_KEY_CACHE_LONGLONG:
update_key_cache_stat_var(dflt_key_cache, (size_t) value);
value= (char*) dflt_key_cache + (ulong)value;
end= longlong10_to_str(*(longlong*) value, buff, 10);
break;
case SHOW_UNDEF:
break; // Return empty string
case SHOW_SYS: // Cannot happen

14
sql/sql_test.cc
View File

@ -441,6 +441,9 @@ static int print_key_cache_status(const char *name, KEY_CACHE *key_cache)
}
else
{
KEY_CACHE_STATISTICS stats;
get_key_cache_statistics(key_cache, 0, &stats);
printf("%s\n\
Buffer_size: %10lu\n\
Block_size: %10lu\n\
@ -457,11 +460,12 @@ reads: %10s\n\n",
(ulong) key_cache->param_buff_size, key_cache->param_block_size,
key_cache->param_division_limit, key_cache->param_age_threshold,
key_cache->param_partitions,
key_cache->blocks_used,key_cache->global_blocks_changed,
llstr(key_cache->global_cache_w_requests,llbuff1),
llstr(key_cache->global_cache_write,llbuff2),
llstr(key_cache->global_cache_r_requests,llbuff3),
llstr(key_cache->global_cache_read,llbuff4));
(ulong)stats.blocks_used,
(ulong)stats.blocks_changed,
llstr(stats.write_requests,llbuff1),
llstr(stats.writes,llbuff2),
llstr(stats.read_requests,llbuff3),
llstr(stats.reads,llbuff4));
}
return 0;
}

15
storage/myisam/mi_test2.c
View File

@ -812,6 +812,8 @@ end:
mi_panic(HA_PANIC_CLOSE); /* Should close log */
if (!silent)
{
KEY_CACHE_STATISTICS stats;
printf("\nFollowing test have been made:\n");
printf("Write records: %d\nUpdate records: %d\nSame-key-read: %d\nDelete records: %d\n", write_count,update,dupp_keys,opt_delete);
if (rec_pointer_size)
@ -834,6 +836,7 @@ end:
puts("Locking used");
if (use_blob)
puts("blobs used");
get_key_cache_statistics(dflt_key_cache, 0, &stats);
printf("key cache status: \n\
blocks used:%10lu\n\
not flushed:%10lu\n\
@ -841,12 +844,12 @@ w_requests: %10lu\n\
writes: %10lu\n\
r_requests: %10lu\n\
reads: %10lu\n",
dflt_key_cache->blocks_used,
dflt_key_cache->global_blocks_changed,
(ulong) dflt_key_cache->global_cache_w_requests,
(ulong) dflt_key_cache->global_cache_write,
(ulong) dflt_key_cache->global_cache_r_requests,
(ulong) dflt_key_cache->global_cache_read);
(ulong) stats.blocks_used,
(ulong) stats.blocks_changed,
(ulong) stats.write_requests,
(ulong) stats.writes,
(ulong) stats.read_requests,
(ulong) stats.reads);
}
end_key_cache(dflt_key_cache,1);
if (blob_buffer)

Write Preview
Loading…
Cancel
Save