mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-29 10:14:19 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

MDEV-12534 Use atomic operations whenever available

Browse source 
Allow 64-bit atomic operations on 32-bit systems,
only relying on HAVE_ATOMIC_BUILTINS_64, disregarding
the width of the register file.

Define UNIV_WORD_SIZE correctly on all systems, including Windows.
In MariaDB 10.0 and 10.1, it was incorrectly defined as 4 on
64-bit Windows.

Define HAVE_ATOMIC_BUILTINS_64 on Windows
(64-bit atomics are available on both 32-bit and 64-bit Windows
platforms; the operations were unnecessarily disabled even on
64-bit Windows).

MONITOR_OS_PENDING_READS, MONITOR_OS_PENDING_WRITES: Enable by default.

os_file_n_pending_preads, os_file_n_pending_pwrites,
os_n_pending_reads, os_n_pending_writes: Remove.
Use the monitor counters instead.

os_file_count_mutex: Remove. On a system that does not support
64-bit atomics, monitor_mutex will be used instead.
This commit is contained in:
Marko Mäkelä 2017-04-19 22:30:18 +03:00
parent 88613e1df6
commit d34a67b067
18 changed files with 214 additions and 405 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
storage/innobase/buf/buf0rea.cc
View file

@ -881,15 +881,11 @@ buf_read_recv_pages(
count++;
if (count > 1000) {
fprintf(stderr,
"InnoDB: Error: InnoDB has waited for"
" 10 seconds for pending\n"
"InnoDB: reads to the buffer pool to"
" be finished.\n"
"InnoDB: Number of pending reads %lu,"
" pending pread calls %lu\n",
(ulong) buf_pool->n_pend_reads,
(ulong) os_file_n_pending_preads);
ib_logf(IB_LOG_LEVEL_ERROR,
"waited for 10 seconds for " ULINTPF
" pending reads to the buffer pool to"
" be finished",
buf_pool->n_pend_reads);
os_aio_print_debug = TRUE;
}

12
storage/innobase/include/os0file.h
View file

@ -2,7 +2,7 @@
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2009, Percona Inc.
Copyright (c) 2017, MariaDB Corporation. All Rights Reserved.
Copyright (c) 2013, 2017, MariaDB Corporation.
Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
@ -51,16 +51,6 @@ extern ibool os_has_said_disk_full;
/** Flag: enable debug printout for asynchronous i/o */
extern ibool os_aio_print_debug;
/** Number of pending os_file_pread() operations */
extern ulint os_file_n_pending_preads;
/** Number of pending os_file_pwrite() operations */
extern ulint os_file_n_pending_pwrites;
/** Number of pending read operations */
extern ulint os_n_pending_reads;
/** Number of pending write operations */
extern ulint os_n_pending_writes;
#ifdef __WIN__
/** We define always WIN_ASYNC_IO, and check at run-time whether

5
storage/innobase/include/os0sync.h
View file

@ -667,10 +667,7 @@ os_atomic_clear(volatile lock_word_t* ptr)
# define HAVE_ATOMIC_BUILTINS
# define HAVE_ATOMIC_BUILTINS_BYTE
# ifndef _WIN32
# define HAVE_ATOMIC_BUILTINS_64
# endif
# define HAVE_ATOMIC_BUILTINS_64
/**********************************************************//**
Atomic compare and exchange of signed integers (both 32 and 64 bit).

62
storage/innobase/include/srv0mon.h
View file

@ -2,6 +2,7 @@
Copyright (c) 2010, 2013, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
@ -541,22 +542,30 @@ on the counters */
/** Increment a monitor counter under mutex protection.
Use MONITOR_INC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be incremented by 1
@param mutex mutex to acquire and relese */
# define MONITOR_MUTEX_INC(mutex, monitor) \
@param enabled whether the monitor is enabled */
#define MONITOR_MUTEX_INC_LOW(mutex, monitor, enabled) \
ut_ad(!mutex_own(mutex)); \
if (MONITOR_IS_ON(monitor)) { \
if (enabled) { \
mutex_enter(mutex); \
if (++MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) { \
MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor); \
} \
mutex_exit(mutex); \
}
/** Increment a monitor counter under mutex protection.
Use MONITOR_INC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be incremented by 1 */
#define MONITOR_MUTEX_INC(mutex, monitor) \
MONITOR_MUTEX_INC_LOW(mutex, monitor, MONITOR_IS_ON(monitor))
/** Decrement a monitor counter under mutex protection.
Use MONITOR_DEC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be decremented by 1
@param mutex mutex to acquire and relese */
# define MONITOR_MUTEX_DEC(mutex, monitor) \
@param enabled whether the monitor is enabled */
#define MONITOR_MUTEX_DEC_LOW(mutex, monitor, enabled) \
ut_ad(!mutex_own(mutex)); \
if (MONITOR_IS_ON(monitor)) { \
mutex_enter(mutex); \
@ -565,13 +574,20 @@ Use MONITOR_DEC if appropriate mutex protection already exists.
} \
mutex_exit(mutex); \
}
/** Decrement a monitor counter under mutex protection.
Use MONITOR_DEC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be decremented by 1 */
#define MONITOR_MUTEX_DEC(mutex, monitor) \
MONITOR_MUTEX_DEC_LOW(mutex, monitor, MONITOR_IS_ON(monitor))
#if defined HAVE_ATOMIC_BUILTINS_64
/** Atomically increment a monitor counter.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor monitor to be incremented by 1 */
# define MONITOR_ATOMIC_INC(monitor) \
if (MONITOR_IS_ON(monitor)) { \
@param monitor monitor to be incremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_INC_LOW(monitor, enabled) \
if (enabled) { \
ib_uint64_t value; \
value = os_atomic_increment_uint64( \
(ib_uint64_t*) &MONITOR_VALUE(monitor), 1); \
@ -584,9 +600,10 @@ Use MONITOR_INC if appropriate mutex protection exists.
/** Atomically decrement a monitor counter.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor monitor to be decremented by 1 */
# define MONITOR_ATOMIC_DEC(monitor) \
if (MONITOR_IS_ON(monitor)) { \
@param monitor monitor to be decremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_DEC_LOW(monitor, enabled) \
if (enabled) { \
ib_uint64_t value; \
value = os_atomic_decrement_uint64( \
(ib_uint64_t*) &MONITOR_VALUE(monitor), 1); \
@ -617,14 +634,29 @@ srv_mon_free(void);
/** Atomically increment a monitor counter.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor monitor to be incremented by 1 */
# define MONITOR_ATOMIC_INC(monitor) MONITOR_MUTEX_INC(&monitor_mutex, monitor)
@param monitor monitor to be incremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_INC_LOW(monitor, enabled) \
MONITOR_MUTEX_INC_LOW(&monitor_mutex, monitor, enabled)
/** Atomically decrement a monitor counter.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor monitor to be decremented by 1 */
# define MONITOR_ATOMIC_DEC(monitor) MONITOR_MUTEX_DEC(&monitor_mutex, monitor)
@param monitor monitor to be decremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_DEC_LOW(monitor, enabled) \
MONITOR_MUTEX_DEC_LOW(&monitor_mutex, monitor, enabled)
#endif /* HAVE_ATOMIC_BUILTINS_64 */
/** Atomically increment a monitor counter if it is enabled.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor monitor to be incremented by 1 */
#define MONITOR_ATOMIC_INC(monitor) \
MONITOR_ATOMIC_INC_LOW(monitor, MONITOR_IS_ON(monitor))
/** Atomically decrement a monitor counter if it is enabled.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor monitor to be decremented by 1 */
#define MONITOR_ATOMIC_DEC(monitor) \
MONITOR_ATOMIC_DEC_LOW(monitor, MONITOR_IS_ON(monitor))
#define MONITOR_DEC(monitor) \
if (MONITOR_IS_ON(monitor)) { \
MONITOR_VALUE(monitor)--; \

12
storage/innobase/include/univ.i
View file

@ -285,22 +285,12 @@ definitions: */
#endif /* !UNIV_MUST_NOT_INLINE */
#ifdef _WIN32
#define UNIV_WORD_SIZE 4
#elif defined(_WIN64)
#define UNIV_WORD_SIZE 8
#else
/** MySQL config.h generated by GNU autoconf will define SIZEOF_LONG in Posix */
#define UNIV_WORD_SIZE SIZEOF_LONG
#endif
#define UNIV_WORD_SIZE SIZEOF_SIZE_T
/** The following alignment is used in memory allocations in memory heap
management to ensure correct alignment for doubles etc. */
#define UNIV_MEM_ALIGNMENT 8
/** The following alignment is used in aligning lints etc. */
#define UNIV_WORD_ALIGNMENT UNIV_WORD_SIZE
/*
DATABASE VERSION CONTROL
========================

196
storage/innobase/os/os0file.cc
View file

@ -2,7 +2,7 @@
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2009, Percona Inc.
Copyright (c) 2012, 2017, MariaDB Corporation. All Rights Reserved.
Copyright (c) 2013, 2017, MariaDB Corporation.
Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
@ -284,21 +284,6 @@ UNIV_INTERN time_t os_last_printout;
UNIV_INTERN ibool os_has_said_disk_full = FALSE;
#if !defined(UNIV_HOTBACKUP) \
&& (!defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8)
/** The mutex protecting the following counts of pending I/O operations */
static os_ib_mutex_t os_file_count_mutex;
#endif /* !UNIV_HOTBACKUP && (!HAVE_ATOMIC_BUILTINS || UNIV_WORD_SIZE < 8) */
/** Number of pending os_file_pread() operations */
UNIV_INTERN ulint os_file_n_pending_preads = 0;
/** Number of pending os_file_pwrite() operations */
UNIV_INTERN ulint os_file_n_pending_pwrites = 0;
/** Number of pending write operations */
UNIV_INTERN ulint os_n_pending_writes = 0;
/** Number of pending read operations */
UNIV_INTERN ulint os_n_pending_reads = 0;
#ifdef UNIV_DEBUG
# ifndef UNIV_HOTBACKUP
/**********************************************************************//**
@ -752,10 +737,6 @@ void
os_io_init_simple(void)
/*===================*/
{
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_file_count_mutex = os_mutex_create();
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD_SIZE < 8 */
for (ulint i = 0; i < OS_FILE_N_SEEK_MUTEXES; i++) {
os_file_seek_mutexes[i] = os_mutex_create();
}
@ -2364,9 +2345,6 @@ os_file_pread(
os_offset_t offset) /*!< in: file offset from where to read */
{
off_t offs;
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
ssize_t n_bytes;
#endif /* HAVE_PREAD && !HAVE_BROKEN_PREAD */
ut_ad(n);
@ -2383,33 +2361,12 @@ os_file_pread(
os_n_file_reads++;
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_increment_ulint(&os_n_pending_reads, 1);
(void) os_atomic_increment_ulint(&os_file_n_pending_preads, 1);
MONITOR_ATOMIC_INC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_preads++;
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* HAVE_ATOMIC_BUILTINS && UNIV_WORD == 8 */
n_bytes = pread(file, buf, n, offs);
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_decrement_ulint(&os_n_pending_reads, 1);
(void) os_atomic_decrement_ulint(&os_file_n_pending_preads, 1);
MONITOR_ATOMIC_DEC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_preads--;
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD == 8 */
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS);
#ifdef HAVE_PREAD
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
ssize_t n_bytes = pread(file, buf, n, offs);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
return(n_bytes);
#else
{
@ -2419,15 +2376,7 @@ os_file_pread(
ulint i;
#endif /* !UNIV_HOTBACKUP */
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_increment_ulint(&os_n_pending_reads, 1);
MONITOR_ATOMIC_INC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* HAVE_ATOMIC_BUILTINS && UNIV_WORD == 8 */
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
#ifndef UNIV_HOTBACKUP
/* Protect the seek / read operation with a mutex */
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
@ -2447,16 +2396,7 @@ os_file_pread(
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_decrement_ulint(&os_n_pending_reads, 1);
MONITOR_ATOIC_DEC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* HAVE_ATOMIC_BUILTINS && UNIV_WORD_SIZE == 8 */
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
return(ret);
}
#endif
@ -2493,32 +2433,11 @@ os_file_pwrite(
os_n_file_writes++;
#if defined(HAVE_PWRITE) && !defined(HAVE_BROKEN_PREAD)
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_pwrites++;
os_n_pending_writes++;
MONITOR_INC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
#else
(void) os_atomic_increment_ulint(&os_n_pending_writes, 1);
(void) os_atomic_increment_ulint(&os_file_n_pending_pwrites, 1);
MONITOR_ATOMIC_INC(MONITOR_OS_PENDING_WRITES);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD < 8 */
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_WRITES);
#ifdef HAVE_PWRITE
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
ret = pwrite(file, buf, (ssize_t) n, offs);
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_pwrites--;
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
#else
(void) os_atomic_decrement_ulint(&os_n_pending_writes, 1);
(void) os_atomic_decrement_ulint(&os_file_n_pending_pwrites, 1);
MONITOR_ATOMIC_DEC(MONITOR_OS_PENDING_WRITES);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD < 8 */
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
return(ret);
#else
@ -2528,10 +2447,7 @@ os_file_pwrite(
ulint i;
# endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes++;
MONITOR_INC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
# ifndef UNIV_HOTBACKUP
/* Protect the seek / write operation with a mutex */
@ -2555,14 +2471,10 @@ func_exit:
os_mutex_exit(os_file_seek_mutexes[i]);
# endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
return(ret);
}
#endif /* !UNIV_HOTBACKUP */
#endif /* HAVE_PWRITE */
}
#endif
@ -2597,6 +2509,7 @@ os_file_read_func(
os_n_file_reads++;
os_bytes_read_since_printout += n;
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS);
try_again:
ut_ad(buf);
@ -2605,10 +2518,7 @@ try_again:
low = (DWORD) offset & 0xFFFFFFFF;
high = (DWORD) (offset >> 32);
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
#ifndef UNIV_HOTBACKUP
/* Protect the seek / read operation with a mutex */
@ -2626,11 +2536,7 @@ try_again:
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
goto error_handling;
}
@ -2640,10 +2546,7 @@ try_again:
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
if (ret && len == n) {
return(TRUE);
@ -2728,6 +2631,7 @@ os_file_read_no_error_handling_func(
os_n_file_reads++;
os_bytes_read_since_printout += n;
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS);
try_again:
ut_ad(buf);
@ -2736,10 +2640,7 @@ try_again:
low = (DWORD) offset & 0xFFFFFFFF;
high = (DWORD) (offset >> 32);
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
#ifndef UNIV_HOTBACKUP
/* Protect the seek / read operation with a mutex */
@ -2757,11 +2658,7 @@ try_again:
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
goto error_handling;
}
@ -2771,10 +2668,7 @@ try_again:
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
if (ret && len == n) {
return(TRUE);
@ -2854,7 +2748,6 @@ os_file_write_func(
ulint n) /*!< in: number of bytes to write */
{
ut_ad(!srv_read_only_mode);
#ifdef __WIN__
BOOL ret;
DWORD len;
@ -2876,14 +2769,12 @@ os_file_write_func(
ut_ad(buf);
ut_ad(n > 0);
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_WRITES);
retry:
low = (DWORD) offset & 0xFFFFFFFF;
high = (DWORD) (offset >> 32);
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes++;
MONITOR_INC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
#ifndef UNIV_HOTBACKUP
/* Protect the seek / write operation with a mutex */
@ -2901,10 +2792,7 @@ retry:
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
ut_print_timestamp(stderr);
@ -2928,10 +2816,7 @@ retry:
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
if (ret && len == n) {
@ -5751,19 +5636,24 @@ os_aio_print(
time_elapsed = 0.001 + difftime(current_time, os_last_printout);
fprintf(file,
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n"
"%lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes,
(ulong) os_n_file_reads,
(ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
"Pending flushes (fsync) log: " ULINTPF
"; buffer pool: " ULINTPF "\n"
ULINTPF " OS file reads, "
ULINTPF " OS file writes, "
ULINTPF " OS fsyncs\n",
fil_n_pending_log_flushes,
fil_n_pending_tablespace_flushes,
os_n_file_reads,
os_n_file_writes,
os_n_fsyncs);
if (os_file_n_pending_preads != 0 || os_file_n_pending_pwrites != 0) {
const ulint n_reads = MONITOR_VALUE(MONITOR_OS_PENDING_READS);
const ulint n_writes = MONITOR_VALUE(MONITOR_OS_PENDING_WRITES);
if (n_reads != 0 || n_writes != 0) {
fprintf(file,
"%lu pending preads, %lu pending pwrites\n",
(ulong) os_file_n_pending_preads,
(ulong) os_file_n_pending_pwrites);
ULINTPF " pending reads, " ULINTPF " pending writes\n",
n_reads, n_writes);
}
if (os_n_file_reads == os_n_file_reads_old) {

5
storage/innobase/srv/srv0mon.cc
View file

@ -2,6 +2,7 @@
Copyright (c) 2010, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
@ -643,11 +644,11 @@ static monitor_info_t innodb_counter_info[] =
MONITOR_DEFAULT_START, MONITOR_OVLD_OS_FSYNC},
{"os_pending_reads", "os", "Number of reads pending",
MONITOR_NONE,
MONITOR_DEFAULT_ON,
MONITOR_DEFAULT_START, MONITOR_OS_PENDING_READS},
{"os_pending_writes", "os", "Number of writes pending",
MONITOR_NONE,
MONITOR_DEFAULT_ON,
MONITOR_DEFAULT_START, MONITOR_OS_PENDING_WRITES},
{"os_log_bytes_written", "os",

4
storage/innobase/srv/srv0srv.cc
View file

@ -1409,10 +1409,10 @@ srv_export_innodb_status(void)
mutex_enter(&srv_innodb_monitor_mutex);
export_vars.innodb_data_pending_reads =
os_n_pending_reads;
MONITOR_VALUE(MONITOR_OS_PENDING_READS);
export_vars.innodb_data_pending_writes =
os_n_pending_writes;
MONITOR_VALUE(MONITOR_OS_PENDING_WRITES);
export_vars.innodb_data_pending_fsyncs =
fil_n_pending_log_flushes

7
storage/innobase/sync/sync0arr.cc
View file

@ -1069,9 +1069,10 @@ sync_array_print_long_waits(
now the values of pending calls of these. */
fprintf(stderr,
"InnoDB: Pending preads %lu, pwrites %lu\n",
(ulong) os_file_n_pending_preads,
(ulong) os_file_n_pending_pwrites);
"InnoDB: Pending reads " UINT64PF
", writes " UINT64PF "\n",
MONITOR_VALUE(MONITOR_OS_PENDING_READS),
MONITOR_VALUE(MONITOR_OS_PENDING_WRITES));
srv_print_innodb_monitor = TRUE;
os_event_set(srv_monitor_event);

14
storage/xtradb/buf/buf0rea.cc
View file

@ -986,15 +986,11 @@ not_to_recover:
count++;
if (count > 1000) {
fprintf(stderr,
"InnoDB: Error: InnoDB has waited for"
" 10 seconds for pending\n"
"InnoDB: reads to the buffer pool to"
" be finished.\n"
"InnoDB: Number of pending reads %lu,"
" pending pread calls %lu\n",
(ulong) buf_pool->n_pend_reads,
(ulong) os_file_n_pending_preads);
ib_logf(IB_LOG_LEVEL_ERROR,
"waited for 10 seconds for " ULINTPF
" pending reads to the buffer pool to"
" be finished",
buf_pool->n_pend_reads);
os_aio_print_debug = TRUE;
}

12
storage/xtradb/include/os0file.h
View file

@ -2,7 +2,7 @@
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2009, Percona Inc.
Copyright (c) 2017, MariaDB Corporation. All Rights Reserved.
Copyright (c) 2013, 2017, MariaDB Corporation.
Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
@ -52,16 +52,6 @@ extern ibool os_has_said_disk_full;
/** Flag: enable debug printout for asynchronous i/o */
extern ibool os_aio_print_debug;
/** Number of pending os_file_pread() operations */
extern ulint os_file_n_pending_preads;
/** Number of pending os_file_pwrite() operations */
extern ulint os_file_n_pending_pwrites;
/** Number of pending read operations */
extern ulint os_n_pending_reads;
/** Number of pending write operations */
extern ulint os_n_pending_writes;
#ifdef __WIN__
/** We define always WIN_ASYNC_IO, and check at run-time whether

5
storage/xtradb/include/os0sync.h
View file

@ -718,10 +718,7 @@ os_atomic_clear(volatile lock_word_t* ptr)
# define HAVE_ATOMIC_BUILTINS
# define HAVE_ATOMIC_BUILTINS_BYTE
# ifndef _WIN32
# define HAVE_ATOMIC_BUILTINS_64
# endif
# define HAVE_ATOMIC_BUILTINS_64
/**********************************************************//**
Atomic compare and exchange of signed integers (both 32 and 64 bit).

62
storage/xtradb/include/srv0mon.h
View file

@ -2,6 +2,7 @@
Copyright (c) 2010, 2013, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
@ -541,22 +542,30 @@ on the counters */
/** Increment a monitor counter under mutex protection.
Use MONITOR_INC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be incremented by 1
@param mutex mutex to acquire and relese */
# define MONITOR_MUTEX_INC(mutex, monitor) \
@param enabled whether the monitor is enabled */
#define MONITOR_MUTEX_INC_LOW(mutex, monitor, enabled) \
ut_ad(!mutex_own(mutex)); \
if (MONITOR_IS_ON(monitor)) { \
if (enabled) { \
mutex_enter(mutex); \
if (++MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) { \
MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor); \
} \
mutex_exit(mutex); \
}
/** Increment a monitor counter under mutex protection.
Use MONITOR_INC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be incremented by 1 */
#define MONITOR_MUTEX_INC(mutex, monitor) \
MONITOR_MUTEX_INC_LOW(mutex, monitor, MONITOR_IS_ON(monitor))
/** Decrement a monitor counter under mutex protection.
Use MONITOR_DEC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be decremented by 1
@param mutex mutex to acquire and relese */
# define MONITOR_MUTEX_DEC(mutex, monitor) \
@param enabled whether the monitor is enabled */
#define MONITOR_MUTEX_DEC_LOW(mutex, monitor, enabled) \
ut_ad(!mutex_own(mutex)); \
if (MONITOR_IS_ON(monitor)) { \
mutex_enter(mutex); \
@ -565,13 +574,20 @@ Use MONITOR_DEC if appropriate mutex protection already exists.
} \
mutex_exit(mutex); \
}
/** Decrement a monitor counter under mutex protection.
Use MONITOR_DEC if appropriate mutex protection already exists.
@param mutex mutex to acquire and release
@param monitor monitor to be decremented by 1 */
#define MONITOR_MUTEX_DEC(mutex, monitor) \
MONITOR_MUTEX_DEC_LOW(mutex, monitor, MONITOR_IS_ON(monitor))
#if defined HAVE_ATOMIC_BUILTINS_64
/** Atomically increment a monitor counter.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor monitor to be incremented by 1 */
# define MONITOR_ATOMIC_INC(monitor) \
if (MONITOR_IS_ON(monitor)) { \
@param monitor monitor to be incremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_INC_LOW(monitor, enabled) \
if (enabled) { \
ib_uint64_t value; \
value = os_atomic_increment_uint64( \
(ib_uint64_t*) &MONITOR_VALUE(monitor), 1); \
@ -584,9 +600,10 @@ Use MONITOR_INC if appropriate mutex protection exists.
/** Atomically decrement a monitor counter.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor monitor to be decremented by 1 */
# define MONITOR_ATOMIC_DEC(monitor) \
if (MONITOR_IS_ON(monitor)) { \
@param monitor monitor to be decremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_DEC_LOW(monitor, enabled) \
if (enabled) { \
ib_uint64_t value; \
value = os_atomic_decrement_uint64( \
(ib_uint64_t*) &MONITOR_VALUE(monitor), 1); \
@ -617,14 +634,29 @@ srv_mon_free(void);
/** Atomically increment a monitor counter.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor monitor to be incremented by 1 */
# define MONITOR_ATOMIC_INC(monitor) MONITOR_MUTEX_INC(&monitor_mutex, monitor)
@param monitor monitor to be incremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_INC_LOW(monitor, enabled) \
MONITOR_MUTEX_INC_LOW(&monitor_mutex, monitor, enabled)
/** Atomically decrement a monitor counter.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor monitor to be decremented by 1 */
# define MONITOR_ATOMIC_DEC(monitor) MONITOR_MUTEX_DEC(&monitor_mutex, monitor)
@param monitor monitor to be decremented by 1
@param enabled whether the monitor is enabled */
# define MONITOR_ATOMIC_DEC_LOW(monitor, enabled) \
MONITOR_MUTEX_DEC_LOW(&monitor_mutex, monitor, enabled)
#endif /* HAVE_ATOMIC_BUILTINS_64 */
/** Atomically increment a monitor counter if it is enabled.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor monitor to be incremented by 1 */
#define MONITOR_ATOMIC_INC(monitor) \
MONITOR_ATOMIC_INC_LOW(monitor, MONITOR_IS_ON(monitor))
/** Atomically decrement a monitor counter if it is enabled.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor monitor to be decremented by 1 */
#define MONITOR_ATOMIC_DEC(monitor) \
MONITOR_ATOMIC_DEC_LOW(monitor, MONITOR_IS_ON(monitor))
#define MONITOR_DEC(monitor) \
if (MONITOR_IS_ON(monitor)) { \
MONITOR_VALUE(monitor)--; \

12
storage/xtradb/include/univ.i
View file

@ -304,22 +304,12 @@ definitions: */
#endif /* !UNIV_MUST_NOT_INLINE */
#ifdef _WIN32
#define UNIV_WORD_SIZE 4
#elif defined(_WIN64)
#define UNIV_WORD_SIZE 8
#else
/** MySQL config.h generated by GNU autoconf will define SIZEOF_LONG in Posix */
#define UNIV_WORD_SIZE SIZEOF_LONG
#endif
#define UNIV_WORD_SIZE SIZEOF_SIZE_T
/** The following alignment is used in memory allocations in memory heap
management to ensure correct alignment for doubles etc. */
#define UNIV_MEM_ALIGNMENT 8
/** The following alignment is used in aligning lints etc. */
#define UNIV_WORD_ALIGNMENT UNIV_WORD_SIZE
/*
DATABASE VERSION CONTROL
========================

181
storage/xtradb/os/os0file.cc
View file

@ -2,7 +2,7 @@
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2009, Percona Inc.
Copyright (c) 2013, 2017, MariaDB Corporation. All Rights Reserved.
Copyright (c) 2013, 2017, MariaDB Corporation.
Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
@ -291,21 +291,6 @@ UNIV_INTERN time_t os_last_printout;
UNIV_INTERN ibool os_has_said_disk_full = FALSE;
#if !defined(UNIV_HOTBACKUP) \
&& (!defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8)
/** The mutex protecting the following counts of pending I/O operations */
static os_ib_mutex_t os_file_count_mutex;
#endif /* !UNIV_HOTBACKUP && (!HAVE_ATOMIC_BUILTINS || UNIV_WORD_SIZE < 8) */
/** Number of pending os_file_pread() operations */
UNIV_INTERN ulint os_file_n_pending_preads = 0;
/** Number of pending os_file_pwrite() operations */
UNIV_INTERN ulint os_file_n_pending_pwrites = 0;
/** Number of pending write operations */
UNIV_INTERN ulint os_n_pending_writes = 0;
/** Number of pending read operations */
UNIV_INTERN ulint os_n_pending_reads = 0;
#ifdef UNIV_DEBUG
# ifndef UNIV_HOTBACKUP
/**********************************************************************//**
@ -887,10 +872,6 @@ void
os_io_init_simple(void)
/*===================*/
{
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_file_count_mutex = os_mutex_create();
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD_SIZE < 8 */
for (ulint i = 0; i < OS_FILE_N_SEEK_MUTEXES; i++) {
os_file_seek_mutexes[i] = os_mutex_create();
}
@ -2580,10 +2561,6 @@ os_file_pread(
trx_t* trx)
{
off_t offs;
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
ssize_t n_bytes;
ssize_t n_read;
#endif /* HAVE_PREAD && !HAVE_BROKEN_PREAD */
ulint sec;
ulint ms;
ib_uint64_t start_time;
@ -2613,22 +2590,16 @@ os_file_pread(
} else {
start_time = 0;
}
#if defined(HAVE_PREAD) && !defined(HAVE_BROKEN_PREAD)
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_increment_ulint(&os_n_pending_reads, 1);
(void) os_atomic_increment_ulint(&os_file_n_pending_preads, 1);
MONITOR_ATOMIC_INC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_preads++;
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* HAVE_ATOMIC_BUILTINS && UNIV_WORD == 8 */
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS);
#ifdef HAVE_PREAD
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
ssize_t n_bytes;
/* Handle partial reads and signal interruptions correctly */
for (n_bytes = 0; n_bytes < (ssize_t) n; ) {
n_read = pread(file, buf, (ssize_t)n - n_bytes, offs);
ssize_t n_read = pread(file, buf, (ssize_t)n - n_bytes, offs);
if (n_read > 0) {
n_bytes += n_read;
offs += n_read;
@ -2640,17 +2611,7 @@ os_file_pread(
}
}
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_decrement_ulint(&os_n_pending_reads, 1);
(void) os_atomic_decrement_ulint(&os_file_n_pending_preads, 1);
MONITOR_ATOMIC_DEC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_preads--;
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD == 8 */
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
if (UNIV_UNLIKELY(start_time != 0))
{
@ -2669,15 +2630,7 @@ os_file_pread(
ulint i;
#endif /* !UNIV_HOTBACKUP */
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_increment_ulint(&os_n_pending_reads, 1);
MONITOR_ATOMIC_INC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* HAVE_ATOMIC_BUILTINS && UNIV_WORD == 8 */
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
#ifndef UNIV_HOTBACKUP
/* Protect the seek / read operation with a mutex */
i = ((ulint) file) % OS_FILE_N_SEEK_MUTEXES;
@ -2707,15 +2660,7 @@ os_file_pread(
os_mutex_exit(os_file_seek_mutexes[i]);
#endif /* !UNIV_HOTBACKUP */
#if defined(HAVE_ATOMIC_BUILTINS) && UNIV_WORD_SIZE == 8
(void) os_atomic_decrement_ulint(&os_n_pending_reads, 1);
MONITOR_ATOIC_DEC(MONITOR_OS_PENDING_READS);
#else
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
#endif /* HAVE_ATOMIC_BUILTINS && UNIV_WORD_SIZE == 8 */
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
if (UNIV_UNLIKELY(start_time != 0)
{
@ -2761,18 +2706,9 @@ os_file_pwrite(
os_n_file_writes++;
#if defined(HAVE_PWRITE) && !defined(HAVE_BROKEN_PREAD)
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_pwrites++;
os_n_pending_writes++;
MONITOR_INC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
#else
(void) os_atomic_increment_ulint(&os_n_pending_writes, 1);
(void) os_atomic_increment_ulint(&os_file_n_pending_pwrites, 1);
MONITOR_ATOMIC_INC(MONITOR_OS_PENDING_WRITES);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD < 8 */
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_WRITES);
#ifdef HAVE_PWRITE
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
/* Handle partial writes and signal interruptions correctly */
for (ret = 0; ret < (ssize_t) n; ) {
@ -2791,17 +2727,7 @@ os_file_pwrite(
}
}
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_mutex_enter(os_file_count_mutex);
os_file_n_pending_pwrites--;
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
#else
(void) os_atomic_decrement_ulint(&os_n_pending_writes, 1);
(void) os_atomic_decrement_ulint(&os_file_n_pending_pwrites, 1);
MONITOR_ATOMIC_DEC(MONITOR_OS_PENDING_WRITES);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD < 8 */
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
return(ret);
#else
@ -2811,10 +2737,7 @@ os_file_pwrite(
ulint i;
# endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes++;
MONITOR_INC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
# ifndef UNIV_HOTBACKUP
/* Protect the seek / write operation with a mutex */
@ -2848,14 +2771,10 @@ func_exit:
os_mutex_exit(os_file_seek_mutexes[i]);
# endif /* !UNIV_HOTBACKUP */
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
return(ret);
}
#endif /* !UNIV_HOTBACKUP */
#endif /* HAVE_PWRITE */
}
#endif
@ -2887,15 +2806,13 @@ os_file_read_func(
os_n_file_reads++;
os_bytes_read_since_printout += n;
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS);
try_again:
ut_ad(buf);
ut_ad(n > 0);
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
memset (&overlapped, 0, sizeof (overlapped));
overlapped.Offset = (DWORD)(offset & 0xFFFFFFFF);
@ -2908,10 +2825,7 @@ try_again:
else if(GetLastError() == ERROR_IO_PENDING) {
ret = GetOverlappedResult(file, &overlapped, (DWORD *)&len, TRUE);
}
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
if (ret && len == n) {
return(TRUE);
@ -2995,15 +2909,13 @@ os_file_read_no_error_handling_func(
os_n_file_reads++;
os_bytes_read_since_printout += n;
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_READS);
try_again:
ut_ad(buf);
ut_ad(n > 0);
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads++;
MONITOR_INC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_READS, monitor);
memset (&overlapped, 0, sizeof (overlapped));
overlapped.Offset = (DWORD)(offset & 0xFFFFFFFF);
@ -3016,10 +2928,7 @@ try_again:
else if(GetLastError() == ERROR_IO_PENDING) {
ret = GetOverlappedResult(file, &overlapped, (DWORD *)&len, TRUE);
}
os_mutex_enter(os_file_count_mutex);
os_n_pending_reads--;
MONITOR_DEC(MONITOR_OS_PENDING_READS);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_READS, monitor);
if (ret && len == n) {
return(TRUE);
@ -3113,12 +3022,10 @@ os_file_write_func(
ut_ad(buf);
ut_ad(n > 0);
const bool monitor = MONITOR_IS_ON(MONITOR_OS_PENDING_WRITES);
retry:
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes++;
MONITOR_INC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_INC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
memset (&overlapped, 0, sizeof (overlapped));
overlapped.Offset = (DWORD)(offset & 0xFFFFFFFF);
@ -3133,10 +3040,7 @@ retry:
ret = GetOverlappedResult(file, &overlapped, (DWORD *)&len, TRUE);
}
os_mutex_enter(os_file_count_mutex);
os_n_pending_writes--;
MONITOR_DEC(MONITOR_OS_PENDING_WRITES);
os_mutex_exit(os_file_count_mutex);
MONITOR_ATOMIC_DEC_LOW(MONITOR_OS_PENDING_WRITES, monitor);
if (ret && len == n) {
@ -4230,10 +4134,6 @@ os_aio_free(void)
}
}
#if !defined(HAVE_ATOMIC_BUILTINS) || UNIV_WORD_SIZE < 8
os_mutex_free(os_file_count_mutex);
#endif /* !HAVE_ATOMIC_BUILTINS || UNIV_WORD_SIZE < 8 */
for (ulint i = 0; i < OS_FILE_N_SEEK_MUTEXES; i++) {
os_mutex_free(os_file_seek_mutexes[i]);
}
@ -5909,19 +5809,24 @@ os_aio_print(
time_elapsed = 0.001 + difftime(current_time, os_last_printout);
fprintf(file,
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n"
"%lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes,
(ulong) os_n_file_reads,
(ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
"Pending flushes (fsync) log: " ULINTPF
"; buffer pool: " ULINTPF "\n"
ULINTPF " OS file reads, "
ULINTPF " OS file writes, "
ULINTPF " OS fsyncs\n",
fil_n_pending_log_flushes,
fil_n_pending_tablespace_flushes,
os_n_file_reads,
os_n_file_writes,
os_n_fsyncs);
if (os_file_n_pending_preads != 0 || os_file_n_pending_pwrites != 0) {
const ulint n_reads = MONITOR_VALUE(MONITOR_OS_PENDING_READS);
const ulint n_writes = MONITOR_VALUE(MONITOR_OS_PENDING_WRITES);
if (n_reads != 0 || n_writes != 0) {
fprintf(file,
"%lu pending preads, %lu pending pwrites\n",
(ulong) os_file_n_pending_preads,
(ulong) os_file_n_pending_pwrites);
ULINTPF " pending reads, " ULINTPF " pending writes\n",
n_reads, n_writes);
}
if (os_n_file_reads == os_n_file_reads_old) {

5
storage/xtradb/srv/srv0mon.cc
View file

@ -2,6 +2,7 @@
Copyright (c) 2010, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
@ -643,11 +644,11 @@ static monitor_info_t innodb_counter_info[] =
MONITOR_DEFAULT_START, MONITOR_OVLD_OS_FSYNC},
{"os_pending_reads", "os", "Number of reads pending",
MONITOR_NONE,
MONITOR_DEFAULT_ON,
MONITOR_DEFAULT_START, MONITOR_OS_PENDING_READS},
{"os_pending_writes", "os", "Number of writes pending",
MONITOR_NONE,
MONITOR_DEFAULT_ON,
MONITOR_DEFAULT_START, MONITOR_OS_PENDING_WRITES},
{"os_log_bytes_written", "os",

4
storage/xtradb/srv/srv0srv.cc
View file

@ -1735,10 +1735,10 @@ srv_export_innodb_status(void)
mutex_enter(&srv_innodb_monitor_mutex);
export_vars.innodb_data_pending_reads =
os_n_pending_reads;
MONITOR_VALUE(MONITOR_OS_PENDING_READS);
export_vars.innodb_data_pending_writes =
os_n_pending_writes;
MONITOR_VALUE(MONITOR_OS_PENDING_WRITES);
export_vars.innodb_data_pending_fsyncs =
fil_n_pending_log_flushes

7
storage/xtradb/sync/sync0arr.cc
View file

@ -1161,9 +1161,10 @@ sync_array_print_long_waits(
now the values of pending calls of these. */
fprintf(stderr,
"InnoDB: Pending preads %lu, pwrites %lu\n",
(ulong) os_file_n_pending_preads,
(ulong) os_file_n_pending_pwrites);
"InnoDB: Pending reads " UINT64PF
", writes " UINT64PF "\n",
MONITOR_VALUE(MONITOR_OS_PENDING_READS),
MONITOR_VALUE(MONITOR_OS_PENDING_WRITES));
srv_print_innodb_monitor = TRUE;
os_event_set(srv_monitor_event);