Skip to content
Permalink
Browse files
MDEV-12266: Skip a lookup when checking free space 
fsp_get_available_space_in_free_extents(): Declare the function static
in the only caller, and take const fil_space_t& as a parameter.
  • Loading branch information
@dr-m
dr-m committed Mar 29, 2018
1 parent 330ecb9 commit c02c329
Show file tree
Hide file tree
Showing 3 changed files with 65 additions and 142 deletions.
63 storage/innobase/fsp/fsp0fsp.cc
View file
@@ -2815,69 +2815,6 @@ fsp_reserve_free_extents(
return(false);
}

/** Calculate how many KiB of new data we will be able to insert to the
tablespace without running out of space.
@param[in] space_id tablespace ID
@return available space in KiB
@retval UINTMAX_MAX if unknown */
uintmax_t
fsp_get_available_space_in_free_extents(
ulint space_id)
{
FilSpace space(space_id);
if (space() == NULL) {
return(UINTMAX_MAX);
}

return(fsp_get_available_space_in_free_extents(space));
}

/** Calculate how many KiB of new data we will be able to insert to the
tablespace without running out of space. Start with a space object that has
been acquired by the caller who holds it for the calculation,
@param[in] space tablespace object from fil_space_acquire()
@return available space in KiB */
uintmax_t
fsp_get_available_space_in_free_extents(
const fil_space_t* space)
{
ut_ad(space->n_pending_ops > 0);

ulint size_in_header = space->size_in_header;
if (size_in_header < FSP_EXTENT_SIZE) {
return(0); /* TODO: count free frag pages and
return a value based on that */
}

/* Below we play safe when counting free extents above the free limit:
some of them will contain extent descriptor pages, and therefore
will not be free extents */
ut_ad(size_in_header >= space->free_limit);
ulint n_free_up =
(size_in_header - space->free_limit) / FSP_EXTENT_SIZE;

page_size_t page_size(space->flags);
if (n_free_up > 0) {
n_free_up--;
n_free_up -= n_free_up / (page_size.physical()
/ FSP_EXTENT_SIZE);
}

/* We reserve 1 extent + 0.5 % of the space size to undo logs
and 1 extent + 0.5 % to cleaning operations; NOTE: this source
code is duplicated in the function above! */

ulint reserve = 2 + ((size_in_header / FSP_EXTENT_SIZE) * 2) / 200;
ulint n_free = space->free_len + n_free_up;

if (reserve > n_free) {
return(0);
}

return(static_cast<uintmax_t>(n_free - reserve)
* FSP_EXTENT_SIZE * (page_size.physical() / 1024));
}

/********************************************************************//**
Marks a page used. The page must reside within the extents of the given
segment. */
126 storage/innobase/handler/ha_innodb.cc
View file
@@ -13823,6 +13823,50 @@ innodb_rec_per_key(
return(rec_per_key);
}

/** Calculate how many KiB of new data we will be able to insert to the
tablespace without running out of space. Start with a space object that has
been acquired by the caller who holds it for the calculation,
@param[in] space tablespace object from fil_space_acquire()
@return available space in KiB */
static uintmax_t
fsp_get_available_space_in_free_extents(const fil_space_t& space)
{
ut_ad(space.n_pending_ops > 0);

ulint size_in_header = space.size_in_header;
if (size_in_header < FSP_EXTENT_SIZE) {
return 0; /* TODO: count free frag pages and
return a value based on that */
}

/* Below we play safe when counting free extents above the free limit:
some of them will contain extent descriptor pages, and therefore
will not be free extents */
ut_ad(size_in_header >= space.free_limit);
ulint n_free_up =
(size_in_header - space.free_limit) / FSP_EXTENT_SIZE;

const ulint size = page_size_t(space.flags).physical();
if (n_free_up > 0) {
n_free_up--;
n_free_up -= n_free_up / (size / FSP_EXTENT_SIZE);
}

/* We reserve 1 extent + 0.5 % of the space size to undo logs
and 1 extent + 0.5 % to cleaning operations; NOTE: this source
code is duplicated in the function above! */

ulint reserve = 2 + ((size_in_header / FSP_EXTENT_SIZE) * 2) / 200;
ulint n_free = space.free_len + n_free_up;

if (reserve > n_free) {
return(0);
}

return(static_cast<uintmax_t>(n_free - reserve)
* FSP_EXTENT_SIZE * (size / 1024));
}

/*********************************************************************//**
Returns statistics information of the table to the MySQL interpreter,
in various fields of the handle object.
@@ -13949,67 +13993,23 @@ ha_innobase::info_low(
m_prebuilt->autoinc_last_value = 0;
}

const page_size_t& page_size
= dict_table_page_size(ib_table);

stats.records = (ha_rows) n_rows;
stats.deleted = 0;
stats.data_file_length
= ((ulonglong) stat_clustered_index_size)
* page_size.physical();
stats.index_file_length
= ((ulonglong) stat_sum_of_other_index_sizes)
* page_size.physical();

/* Since fsp_get_available_space_in_free_extents() is
acquiring latches inside InnoDB, we do not call it if we
are asked by MySQL to avoid locking. Another reason to
avoid the call is that it uses quite a lot of CPU.
See Bug#38185. */
if (flag & HA_STATUS_NO_LOCK
|| !(flag & HA_STATUS_VARIABLE_EXTRA)) {
/* We do not update delete_length if no
locking is requested so the "old" value can
remain. delete_length is initialized to 0 in
the ha_statistics' constructor. Also we only
need delete_length to be set when
HA_STATUS_VARIABLE_EXTRA is set */
} else if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
/* Avoid accessing the tablespace if
innodb_crash_recovery is set to a high value. */
stats.delete_length = 0;
} else {
uintmax_t avail_space;

avail_space = fsp_get_available_space_in_free_extents(
ib_table->space);

if (avail_space == UINTMAX_MAX) {
THD* thd;
char errbuf[MYSYS_STRERROR_SIZE];

thd = ha_thd();

push_warning_printf(
thd,
Sql_condition::WARN_LEVEL_WARN,
ER_CANT_GET_STAT,
"InnoDB: Trying to get the free"
" space for table %s but its"
" tablespace has been discarded or"
" the .ibd file is missing. Setting"
" the free space to zero."
" (errno: %d - %s)",
ib_table->name.m_name, errno,
my_strerror(errbuf, sizeof(errbuf),
errno));

stats.delete_length = 0;
} else {
stats.delete_length = avail_space * 1024;
}
if (fil_space_t* space = fil_space_acquire_silent(
ib_table->space)) {
const ulint size = page_size_t(space->flags)
.physical();
stats.data_file_length
= ulonglong(stat_clustered_index_size)
* size;
stats.index_file_length
= ulonglong(stat_sum_of_other_index_sizes)
* size;
stats.delete_length = 1024
* fsp_get_available_space_in_free_extents(
*space);
fil_space_release(space);
}

stats.check_time = 0;
stats.mrr_length_per_rec= (uint)ref_length + 8; // 8 = max(sizeof(void *));

@@ -14701,9 +14701,13 @@ ha_innobase::update_table_comment(
#define SSTR( x ) reinterpret_cast< std::ostringstream & >( \
( std::ostringstream() << std::dec << x ) ).str()

fk_str.append("InnoDB free: ");
fk_str.append(SSTR(fsp_get_available_space_in_free_extents(
m_prebuilt->table->space)));
if (fil_space_t* space = fil_space_acquire_silent(
m_prebuilt->table->space)) {
fk_str.append("InnoDB free: ");
fk_str.append(SSTR(fsp_get_available_space_in_free_extents(
*space)));
fil_space_release(space);
}

fk_str.append(dict_print_info_on_foreign_keys(
FALSE, m_prebuilt->trx,
18 storage/innobase/include/fsp0fsp.h
View file
@@ -527,24 +527,6 @@ fsp_reserve_free_extents(
mtr_t* mtr,
ulint n_pages = 2);

/** Calculate how many KiB of new data we will be able to insert to the
tablespace without running out of space.
@param[in] space_id tablespace ID
@return available space in KiB
@retval UINTMAX_MAX if unknown */
uintmax_t
fsp_get_available_space_in_free_extents(
ulint space_id);

/** Calculate how many KiB of new data we will be able to insert to the
tablespace without running out of space. Start with a space object that has
been acquired by the caller who holds it for the calculation,
@param[in] space tablespace object from fil_space_acquire()
@return available space in KiB */
uintmax_t
fsp_get_available_space_in_free_extents(
const fil_space_t* space);

/**********************************************************************//**
Frees a single page of a segment. */
void

0 comments on commit c02c329

Please sign in to comment.