14.8.1 InnoDB Startup Configuration
The first decisions to make about
InnoDB configuration involve the configuration of data files, log files, page size, and memory buffers. It is recommended that you define data file, log file, and page size configuration before creating the
InnoDB instance. Modifying data file or log file configuration after the
InnoDB instance is created may involve a non-trivial procedure, and page size can only be defined when the
InnoDB instance is first initialized.
In addition to these topics, this section provides information about specifying
InnoDB options in a configuration file, viewing
InnoDB initialization information, and important storage considerations.
Because MySQL uses data file, log file, and page size configuration settings to initialize the
InnoDB instance, it is recommended that you define these settings in a configuration file that MySQL reads at startup, prior to initializing
InnoDB for the first time.
InnoDB is initialized when the MySQL server is started, and the first initialization of
InnoDB normally occurs the first time you start the MySQL server.
You can place
InnoDB options in the
[mysqld] group of any option file that your server reads when it starts. The locations of MySQL option files are described in Section 220.127.116.11, “Using Option Files”.
For example, on Windows, if mysqld is located in
C:\Program Files\MySQL\MySQL Server 5.7\bin, start the MySQL server like this:
C:\> "C:\Program Files\MySQL\MySQL Server 5.7\bin\mysqld" --console
On Unix-like systems, mysqld is located in the
bin directory of your MySQL installation:
shell> bin/mysqld --user=mysql &
If you do not send server output to the console, check the error log after startup to see the initialization information
InnoDB printed during the startup process.
For information about starting MySQL using other methods, see Section 2.10.5, “Starting and Stopping MySQL Automatically”.
InnoDB does not open all user tables and associated data files at startup. However,
InnoDB does check for the existence of tablespace files (
*.ibd files) that are referenced in the data dictionary. If a tablespace file is not found,
InnoDB logs an error and continues the startup sequence. Tablespace files that are referenced in the redo log may be opened during crash recovery for redo application.
Review the following storage-related considerations before proceeding with your startup configuration.
In some cases, database performance improves if the data is not all placed on the same physical disk. Putting log files on a different disk from data is very often beneficial for performance. For example, you can place system tablespace data files and log files on different disks. You can also use raw disk partitions (raw devices) for
InnoDBdata files, which may speed up I/O. See Using Raw Disk Partitions for the System Tablespace.
InnoDBis a transaction-safe (ACID compliant) storage engine for MySQL that has commit, rollback, and crash-recovery capabilities to protect user data. However, it cannot do so if the underlying operating system or hardware does not work as advertised. Many operating systems or disk subsystems may delay or reorder write operations to improve performance. On some operating systems, the very
fsync()system call that should wait until all unwritten data for a file has been flushed might actually return before the data has been flushed to stable storage. Because of this, an operating system crash or a power outage may destroy recently committed data, or in the worst case, even corrupt the database because of write operations having been reordered. If data integrity is important to you, perform some “pull-the-plug” tests before using anything in production. On macOS,
InnoDBuses a special
fcntl()file flush method. Under Linux, it is advisable to disable the write-back cache.
On ATA/SATA disk drives, a command such
hdparm -W0 /dev/hdamay work to disable the write-back cache. Beware that some drives or disk controllers may be unable to disable the write-back cache.
With regard to
InnoDBrecovery capabilities that protect user data,
InnoDBuses a file flush technique involving a structure called the doublewrite buffer, which is enabled by default (
innodb_doublewrite=ON). The doublewrite buffer adds safety to recovery following a crash or power outage, and improves performance on most varieties of Unix by reducing the need for
fsync()operations. It is recommended that the
innodb_doublewriteoption remains enabled if you are concerned with data integrity or possible failures. For additional information about the doublewrite buffer, see Section 14.12.1, “InnoDB Disk I/O”.
Before using NFS with
InnoDB, review potential issues outlined in Using NFS with MySQL.
Running MySQL server on a 4K sector hard drive on Windows is not supported with
innodb_flush_method=async_unbuffered, which is the default setting. The workaround is to use
innodb_data_file_path startup option defines the name, size, and attributes of
InnoDB system tablespace data files. If you do not configure this option prior to initializing the MySQL server, the default behavior is to create a single auto-extending data file, slightly larger than 12MB, named
mysql> SHOW VARIABLES LIKE 'innodb_data_file_path'; +-----------------------+------------------------+ | Variable_name | Value | +-----------------------+------------------------+ | innodb_data_file_path | ibdata1:12M:autoextend | +-----------------------+------------------------+
The full data file specification syntax includes the file name, file size,
autoextend attribute, and
File sizes are specified in kilobytes, megabytes, or gigabytes by appending
G to the size value. If specifying the data file size in kilobytes, do so in multiples of 1024. Otherwise, kilobyte values are rounded to nearest megabyte (MB) boundary. The sum of file sizes must be, at a minimum, slightly larger than 12MB.
You can specify more than one data file using a semicolon-separated list. For example:
max attributes can be used only for the data file that is specified last.
autoextend attribute is specified, the data file automatically increases in size by 64MB increments as space is required. The
innodb_autoextend_increment variable controls the increment size.
To specify a maximum size for an auto-extending data file, use the
max attribute following the
autoextend attribute. Use the
max attribute only in cases where constraining disk usage is of critical importance. The following configuration permits
ibdata1 to grow to a limit of 500MB:
A minimum file size is enforced for the first system tablespace data file to ensure that there is enough space for doublewrite buffer pages. The following table shows minimum file sizes for each
InnoDB page size. The default
InnoDB page size is 16384 (16KB).
|Page Size (innodb_page_size)||Minimum File Size|
|16384 (16KB) or less||3MB|
If your disk becomes full, you can add a data file on another disk. For instructions, see Resizing the System Tablespace.
The size limit for individual files is determined by your operating system. You can set the file size to more than 4GB on operating systems that support large files. You can also use raw disk partitions as data files. See Using Raw Disk Partitions for the System Tablespace.
InnoDB is not aware of the file system maximum file size, so be cautious on file systems where the maximum file size is a small value such as 2GB.
System tablespace files are created in the data directory by default (
datadir). To specify an alternate location, use the
innodb_data_home_dir option. For example, to create a system tablespace data file in a directory named
myibdata, use this configuration:
[mysqld] innodb_data_home_dir = /myibdata/ innodb_data_file_path=ibdata1:50M:autoextend
A trailing slash is required when specifying a value for
InnoDB does not create directories, so ensure that the specified directory exists before you start the server. Also, ensure sure that the MySQL server has the proper access rights to create files in the directory.
InnoDB forms the directory path for each data file by textually concatenating the value of
innodb_data_home_dir to the data file name. If
innodb_data_home_dir is not defined, the default value is “./”, which is the data directory. (The MySQL server changes its current working directory to the data directory when it begins executing.)
If you specify
innodb_data_home_dir as an empty string, you can specify absolute paths for data files listed in the
innodb_data_file_path value. The following configuration is equivalent to the preceding one:
[mysqld] innodb_data_home_dir = innodb_data_file_path=/myibdata/ibdata1:50M:autoextend
InnoDB creates two 5MB redo log files in the data directory named
The following options can be used to modify the default configuration:
You might use this option to place
InnoDBlog files in a different physical storage location than
InnoDBdata files to avoid potential I/O resource conflicts. For example:
[mysqld] innodb_log_group_home_dir = /dr3/iblogsNote
InnoDBdoes not create directories, so make sure that the log directory exists before you start the server. Use the Unix or DOS
mkdircommand to create any necessary directories.
Make sure that the MySQL server has the proper access rights to create files in the log directory. More generally, the server must have access rights in any directory where it needs to create log files.
innodb_log_files_in_groupdefines the number of log files in the log group. The default and recommended value is 2.
innodb_log_file_sizedefines the size in bytes of each log file in the log group. The combined size of log files (
innodb_log_files_in_group) cannot exceed a maximum value that is slightly less than 512GB. A pair of 255 GB log files, for example, approaches the limit but does not exceed it. The default log file size is 48MB. Generally, the combined size of the log files should be large enough that the server can smooth out peaks and troughs in workload activity, which often means that there is enough redo log space to handle more than an hour of write activity. The larger the value, the less checkpoint flush activity is needed in the buffer pool, saving disk I/O. For additional information, see Section 8.5.4, “Optimizing InnoDB Redo Logging”.
InnoDB undo logs are part of the system tablespace. However, you can choose to store
InnoDB undo logs in one or more separate undo tablespaces, typically on a different storage device.
innodb_undo_directory configuration option defines the path where
InnoDB creates separate tablespaces for the undo logs. This option is typically used in conjunction with the
innodb_undo_tablespaces options, which determine the disk layout of the undo logs outside the system tablespace.
innodb_undo_tablespaces is deprecated and will be removed in a future release.
For more information, see Section 18.104.22.168, “Undo Tablespaces”.
InnoDB creates a single auto-extending temporary tablespace data file named
ibtmp1 that is slightly larger than 12MB in the
innodb_data_home_dir directory. The default temporary tablespace data file configuration can be modified at startup using the
innodb_temp_data_file_path configuration option.
innodb_temp_data_file_path option specifies the path, file name, and file size for
InnoDB temporary tablespace data files. The full directory path for a file is formed by concatenating
innodb_data_home_dir to the path specified by
innodb_temp_data_file_path. File size is specified in KB, MB, or GB (1024MB) by appending K, M, or G to the size value. The sum of the sizes of the files must be slightly larger than 12MB.
An autoextending temporary tablespace data file can become large in environments that use large temporary tables or that use temporary tables extensively. A large data file can also result from long running queries that use temporary tables. To prevent the temporary data file from becoming too large, configure the
innodb_temp_data_file_path option to specify a maximum data file size. For more information see Managing Temporary Tablespace Data File Size.
innodb_page_size option specifies the page size for all
InnoDB tablespaces in a MySQL instance. This value is set when the instance is created and remains constant afterward. Valid values are 64KB, 32KB, 16KB (the default), 8KB, and 4KB. Alternatively, you can specify page size in bytes (65536, 32768, 16384, 8192, 4096).
The default page size of 16KB is appropriate for a wide range of workloads, particularly for queries involving table scans and DML operations involving bulk updates. Smaller page sizes might be more efficient for OLTP workloads involving many small writes, where contention can be an issue when a single page contains many rows. Smaller pages might also be efficient with SSD storage devices, which typically use small block sizes. Keeping the
InnoDB page size close to the storage device block size minimizes the amount of unchanged data that is rewritten to disk.
MySQL allocates memory to various caches and buffers to improve performance of database operations. When allocating memory for
InnoDB, always consider memory required by the operating system, memory allocated to other applications, and memory allocated for other MySQL buffers and caches. For example, if you use
MyISAM tables, consider the amount of memory allocated for the key buffer (
key_buffer_size). For an overview of MySQL buffers and caches, see Section 22.214.171.124, “How MySQL Uses Memory”.
Buffers specific to
InnoDB are configured using the following parameters:
innodb_buffer_pool_sizedefines size of the buffer pool, which is the memory area that holds cached data for
InnoDBtables, indexes, and other auxiliary buffers. The size of the buffer pool is important for system performance, and it is typically recommended that
innodb_buffer_pool_sizeis configured to 50 to 75 percent of system memory. The default buffer pool size is 128MB. For additional guidance, see Section 126.96.36.199, “How MySQL Uses Memory”. For information about how to configure
InnoDBbuffer pool size, see Section 188.8.131.52, “Configuring InnoDB Buffer Pool Size”. Buffer pool size can be configured at startup or dynamically.
On systems with a large amount of memory, you can improve concurrency by dividing the buffer pool into multiple buffer pool instances. The number of buffer pool instances is controlled by the by
innodb_buffer_pool_instancesoption. By default,
InnoDBcreates one buffer pool instance. The number of buffer pool instances can be configured at startup. For more information, see Section 184.108.40.206, “Configuring Multiple Buffer Pool Instances”.
innodb_log_buffer_sizedefines the size in bytes of the buffer that
InnoDBuses to write to the log files on disk. The default size is 16MB. A large log buffer enables large transactions to run without a need to write the log to disk before the transactions commit. If you have transactions that update, insert, or delete many rows, you might consider increasing the size of the log buffer to save disk I/O.
innodb_log_buffer_sizecan be configured at startup. For related information, see Section 8.5.4, “Optimizing InnoDB Redo Logging”.
On 32-bit GNU/Linux x86, be careful not to set memory usage too high.
glibc may permit the process heap to grow over thread stacks, which crashes your server. It is a risk if the memory allocated to the mysqld process for global and per-thread buffers and caches is close to or exceeds 2GB.
A formula similar to the following that calculates global and per-thread memory allocation for MySQL can be used to estimate MySQL memory usage. You may need to modify the formula to account for buffers and caches in your MySQL version and configuration. For an overview of MySQL buffers and caches, see Section 220.127.116.11, “How MySQL Uses Memory”.
innodb_buffer_pool_size + key_buffer_size + max_connections*(sort_buffer_size+read_buffer_size+binlog_cache_size) + max_connections*2MB
Each thread uses a stack (often 2MB, but only 256KB in MySQL binaries provided by Oracle Corporation.) and in the worst case also uses
sort_buffer_size + read_buffer_size additional memory.
On Linux, if the kernel is enabled for large page support,
InnoDB can use large pages to allocate memory for its buffer pool. See Section 18.104.22.168, “Enabling Large Page Support”.