Search

Decrease MySQL Core Dump Size by Not including the InnoDB Buffer Pool

When effects go awful erroneous and a process crashes, one of the most controlling things to examine the reason of the crash is a core dump. As the volume of memory assigned to processes such as MySQL has improved – in some cases pending 1TiB of memory – allowing core dumps can reason snags of their own. MySQL Server 8.0.14 and advanced provisions an option to decrease the size of the core dump which will be conversed in this blog.


Naturally, the main only user of memory for MySQL is the InnoDB buffer pool. This is used to cache the information and indexes for tables with the InnoDB storage engine (the defaulting). It is infrequently significant to know what is kept in the InnoDB buffer pool when examining a crash, so a good way to decrease the core dump size is to eliminate the buffer pool. In MySQL 8.0.14 innodb_buffer_pool_in_core_file conformation option was supplementary for this resolve. It defaults to ON which resources the buffer pool is involved in the core dumps (same actions as in older publications).


Let’s look a bit extra into core dumps, how to allow them, why you may need to ignore the InnoDB buffer pool, and a sample.

Enabling Core Dumps

Core dumps can be allowed by together with the core-file option in the MySQL arrangement. It is inactivated by default. However, on Linux/Unix it is in overall not enough to allow core-file to get a core dump in situation of a crash as the system will also bound the size of a core dump. Typically, this bound is 0 by default.


The of the steps essential to enable core dumps rest on the Linux dispersal used. The subsequent will debate the core-file possibility and the limit on the core size. Though, the careful steps essential may vary for your system and perhaps include extra steps.


Enabling Core Dumps in MySQL

As stated, the option in MySQL to allow core dumps is core-file. This can only be established using the MySQL formation file (my.cnf or my.ini). For sample:


Core Size Limit

Linux contains various restrictions on the resources a process can usage. This helps progress the constancy of the system as a whole, but the defaulting limits may be too limiting for to some degree like a database host where one process uses maximum of the possessions. One of the limits is the size of the core dump and naturally the default limit is 0.


You can validate the existing limits for your process by means of the proc file system, for instance (presumptuous only a only mysqld process on the system):

There are numerous ways to transformation the limits for MySQL and which one to practice rest on how you start MySQL. If you start MySQL from the command-line, you can only use the ulimit command primary:

This has usual the limit for the core file size to limitless.


You can also organize the limit in the /etc/security/limits.conf file or in a original file in /etc/security/limits.d/. This is a healthier way to persist a set and permits you for instance to arrange the limits for a certain user. For example, to set the core dump file size to infinite for the mysql user:

However, on circulations using systemd (together with Oracle Linux 7, Red Hat Enterprise Linux (RHEL) 7, and CentOS 7), systemd entirely overlooks /etc/security/limits.conf. As an alternative you need to use the facility file for the process. For MySQL this is the /usr/lib/systemd/system/mysqld.service file, or if you have several cases on one host, /usr/lib/systemd/system/mysqld@.service. If you use Debian, change mysqld with mysql. The choice to set in the facility file is LimitCore, for instance:

If you use mysqld_safe to twitch MySQL, you can usage the core-file-size choice (in the [mysqld_safe] group in the MySQL formation file or on the command-line) to transformation the limit. This needs that the hard limit is high enough for the demanded limit.


Difficulties with Core Dumps

Over time the amount of memory allocated to MySQL has grown. This particularly applies to the InnoDB buffer pool – as databases handle more data, there is also a greater need to cache the most used data and indexes in memory. Today, some MySQL examples have total memory provisions approaching 1TiB.


When a core dump occurs, the memory assigned to the process is written out to disk. For processes consuming a large volume of memory, this may yield some time. Besides, there is a likelihood that the system might run out of disk, mainly if recurring crashes happen. The disk space usage can mostly be an matter when MySQL is successively as a service as it is expected the core file in that case is written to the data directory. From a funding observation, it is also less than insignificant to share a core dump that is numerous hundred gigabytes huge.


The InnoDB buffer pool is in utmost cases the major supplier – it can simply contribute 75% or more of the total core dump proportions. So, apart from the buffer pool can meaningfully decrease the size of the core dump. I will give an sample at the finish of the blog.


Example

To surface off this blog, let’s look at an instance. In this case, MySQL has been arranged with innodb_buffer_pool_size = 2G and data has been burdened, so most of the buffer is in use:

And from the output of top

When MySQL is killed with signal 11 (segmentation fault), a core dump is formed. Deprived of innodb_buffer_pool_in_core_file, the core dump is nearly 3 gigabytes (see productivity at the end of the blog).


If the new feature is allowed by adding innodb_buffer_pool_in_core_file to the configuration file or by keep on it.

The modification takes effect instantly. The core dump will here and now be much reduced – about the size of the buffer pool lesser:

Here core.11142 is with innodb_buffer_pool_in_core_file permitted and core.14456 with the choice deactivated.

14 views

Call

T: +44 7825018241

Follow me

 

© 2019 by GoplarDB 

All Rights Reserved

Powered by: Goplar LTD

  • LinkedIn Social Icon
  • Twitter Clean