MySQL Server Overloaded – Performance Tuning Tips

MySQLmysql-5.1performanceperformance-tuningquery-performance

I have a MySQL 5.1 server that is struggling. We have too many rows in some of the tables and we do not have enough RAM – currently only 32 GB RAM.

I have RAM begin delivered tomorrow, but I cannot install until Sunday. Between then and now (without deleting rows) I am wanting to understand if there are any tweaks I may be able to consider to slightly improve performance.

The largest problem is we have one table with 32+ million records. Any select against that table is taking quite some time (as you might expect).

My assumption is the machine is heavily utilizing HDD. But I also see high CPU utilization for the mysqld process.

I have checked for fragmented tables and optimized the ones that were fragmented.

The server has 10 HDDs working in a RAID 10 array. So the I/O has read and write speed improvements.

InnoDB Read buffer efficiency: 99.98% (35291508797 hits/ 35299695194 total)
InnoDB Write Log efficiency: 81.46% (36334605 hits/ 44602585 total)

Any thoughts or suggestions would be greatly appreciated.

Here is the my.cfg file:

[mysqld]
innodb_file_per_table
skip-external-locking
port                            = 3306
socket                          = /var/lib/mysql/mysql.sock
max_connections                 = 256
key_buffer_size                 = 256M
max_allowed_packet              = 100M
table_open_cache                = 256
sort_buffer_size                = 1M
read_buffer_size                = 1M
read_rnd_buffer_size            = 4M
myisam_sort_buffer_size         = 64M
thread_cache_size               = 8
query_cache_size                = 16M
max_heap_table_size             = 512M
tmp_table_size                  = 512M
wait_timeout                    = 600
general_log_file                = /var/log/mysql/mysql.general.log
general_log                     = 0
log-slow-queries                = /var/log/mysql/mysql-slow.log
long_query_time                 = 60

# setup replication master:
server-id                       = 1
binlog-format                   = mixed
log-bin                         = /var/log/mysql/mysql-bin.log
datadir                         = /var/lib/mysql
innodb_flush_log_at_trx_commit  = 1
sync_binlog                     = 1

# InnoDB tables
innodb_flush_log_at_trx_commit  = 2
innodb_additional_mem_pool_size = 256M
innodb_buffer_pool_size         = 20G
innodb_lock_wait_timeout        = 120
innodb_log_buffer_size          = 32M
innodb_log_file_size            = 1024M

[mysqld_safe]
log-error                       = /var/log/mysqld.log
pid-file                        = /var/run/mysqld/mysqld.pid

[mysqldump]
quick
max_allowed_packet              = 16M

[mysql]
no-auto-rehash
prompt                          =\u:>\\_

[myisamchk]
key_buffer_size                 = 128M
sort_buffer_size                = 128M
read_buffer                     = 2M
write_buffer                    = 2M

[mysqlhotcopy]
interactive-timeout

We have an application that utilizes this database. This app uses a framework that, for page queries, runs a count() query for pagination. Those count() queries for pagination are many of the ones I see with lengthy run times.

Here is the requested information:

SHOW TABLE STATUS:

| Name | Engine | Version | Row_format | Rows     | Avg_row_length | Data_length | Max_data_length   | Index_length | Data_free | Auto_increment | Create_time         | Update_time         | Check_time | Collation         | Checksum | Create_options | Comment |
| intz | InnoDB | 10      | Compact    | 37508536 |            562 | 21083717632 |                 0 |  15220752384 |   5242880 |       42680391 | 2016-07-26 12:05:22 | NULL                | NULL       | latin1_swedish_ci |     NULL |

…it looks like we are just over 20 GB.

SELECT STATEMENT:

SELECT 
    COUNT(*) AS count
FROM
   intz AS INTz
WHERE
    ((INTz.call_id_string LIKE '%3145551212%')
  OR (INTz.original_call_id LIKE '%3145551212%')
  OR (INTz.telephone_number LIKE '%3145551212%')
  OR (INTz.id = 3145551212)
  OR (INTz.ani LIKE '%3145551212%')
  OR (INTz.dnis LIKE '%3145551212%')
  OR (INTz.customer_account LIKE '%3145551212%'));

…that select count(*) will take roughly 75 seconds to run.

EXPLAIN SELECT:

+----+-------------+-------------+-------+-----------------+--------------+---------+------+----------+--------------------------+
| id | select_type | table | type  | possible_keys   | key          | key_len | ref  | rows     | Extra                    |
+----+-------------+-------------+-------+-----------------+--------------+---------+------+----------+--------------------------+
|  1 | SIMPLE      | intz  | index | id,search_index | search_index | 313     | NULL | 40707970 | Using where; Using index |
+----+-------------+-------------+-------+-----------------+--------------+---------+------+----------+--------------------------+

I also have an index on those fields:

alter table intz add index search_index (id,call_id_string,original_call_id,telephone_number,ani,dnis,customer_account);

Best Answer

High CPU and/or I/O -- Find the slowest queries, provide them, plus EXPLAIN SELECT ... and SHOW CREATE TABLE. This is the most likely way to solve your problem. The fix may be a simple as adding a 'composite' index.

How big is the table? (SHOW TABLE STATUS) If it is less than 20GB, the extra RAM may not help.

The settings are reasonable for 32GB of RAM. Be sure to increase (only) innodb_buffer_pool_size to about 70% of RAM after adding more.

PARTITIONing came with 5.1. However, there are very few cases where it provides any performance benefits. Let's see the queries and schema before embarking blindly on such. BTW, it was not until 5.1.43 that this construct was added: PARTITION BY RANGE(UNIX_TIMESTAMP(col)). More on partitioning.

Addenda

OR and LIKE with leading wildcard == table scan (or index scan in your case). The Index does not help much since it is nearly as big as the table.

Add an extra column (or maybe an extra table) that contains the concatenation of those search columns. Build a FULLTEXT index on it. Then search with MATCH(combined_col) AGAINST (+3145551212 IN BOOLEAN MODE). It will run a thousand times as fast; the "overhead" will vanish. And you will regret buying the extra RAM.

Use it for your query as well as for your count.

But there are limitations (word length, definition of "word", etc).

Related Solutions

MySQL – Master Binlog Corruption

Surprisingly, that's not gibberish.

That indeed appears at the top of binlogs whenever you do mysqlbinlog to a binary log generated using MySQL 5.1 and MySQL 5.5. You will not see that gibberish in binary logs for MySQL 5.0 and back.

This is why the start point for replication from an empty binary log is

107 for MySQL 5.5
106 for MySQL 5.1
98 for MySQL 5.0 and back

This is good to remember if you do MySQL Replication where the Master if MySQL 5.1 and the slave is MySQL 5.0. This could present a really big headache.

Replication from Master using 5.0 and Slave using 5.1 works fine, not the other way around.(According to MySQL Documentation, it is generally not supported for 3 reasons: 1) Binary Log Format, 2) Row-based Replication, 3) SQL Incompatibility).

Anyway, do a mysqlbinlog on the offending binary log on the master. If the resulting dump produces gibberish in the middle of the dump (which I have seen a couple of times in my DBA career) you may have to skip to position 98 (MySQL 5.0) or 106 (MySQL 5.1) or 107 (MySQL 5.5) of the master's next binary log and start replicating from there (SOB :( you may need to use MAATKIT tools mk-table-checksum and mk-table-sync to reload master changes not on the slave [if you want to be a hero]; even worse, mysqldump the master and reload the slave and start replication totally over [if you don't want to be a hero])

If the mysqlbinlog of the master is completely readable after the top gibberish you saw, it is possible the master's binary log is fine but the relay log on the slave is corrupt (due to transmission/CRC errors). If that's the case, just reload the relay logs by issuing the CHANGE MASTER TO command as follows:

STOP SLAVE;
CHANGE MASTER TO
MASTER_HOST='< master-host ip or DNS >',
MASTER_PORT=3306,
MASTER_USER='< usernmae >',
MASTER_PASSWORD='< password >',
MASTER_LOG_FILE='< MMMM >',
MASTER_LOG_POS=< PPPP >;
START SLAVE;

Where

MMMM is the last file used from the Master that was last processed on the Slave
PPPP is the last position used from the Master that was last processed on the Slave

You can get MMMM and PPPP by doing SHOW SLAVE STATUS\G and using

Relay_Master_Log_File for MMMM
Exec_Master_Log_Pos for PPPP

Try it out and let me know !!!

BTW running CHANGE MASTER TO command erases the slave's current relay logs and starts fresh.

Mysql – How to debug a db memory-leak causing thesql to go before it’s own limits

...even surpassing it's theorically maximum possible allocation.

[OK] Maximum possible memory usage: 7.3G (46% of installed RAM)

There is not actually a way to calculate maximum possible memory usage for MySQL, because there is no cap on the memory it can request from the system.

The calculation done by mysqltuner.pl is only an estimate, based on a formula that doesn't take into account all possible variables, because if all possible variables were taken into account, the answer would always be "infinite." It's unfortunate that it's labeled this way.

Here is my theory on what's contributing to your excessive memory usage:

thread_cache_size       = 128

Given that your max_connections is set to 200, the value of 128 for thread_cache_size seems far too high. Here's what makes me think this might be contributing to your problem:

When a thread is no longer needed, the memory allocated to it is released and returned to the system unless the thread goes back into the thread cache. In that case, the memory remains allocated.

^{http://dev.mysql.com/doc/refman/5.6/en/memory-use.html}

If your workload causes even an occasional client thread to require a large amount of memory, those threads may be holding onto that memory, then going back to the pool and sitting around, continuing to hold on to memory they don't technically "need" any more, on the premise that holding on to the memory is less costly than releasing it if you're likely to need it again.

I think it's worth a try to do the following, after first making a note of how much memory MySQL is using at the moment.

Note how many threads are currently cached:

mysql> show status like 'Threads_cached';
+----------------+-------+
| Variable_name  | Value |
+----------------+-------+
| Threads_cached | 9     |
+----------------+-------+
1 row in set (0.00 sec)

Next, disable the thread cache.

mysql> SET GLOBAL thread_cache_size = 0;

This disables the thread cache, but the cached threads will stay in the pool until they're used one more time. Disconnect from the server, then reconnect and repeat.

mysql> show status like 'Threads_cached';

Continue disconnecting, reconnecting, and checking until the counter reaches 0.

Then, see how much memory MySQL is holding.

You may see a decrease, possibly significant, and then again you may not. I tested this on one of my systems, which had 9 threads in the cache. Once those threads had all been cleared out of the cache, the total memory held by MySQL did decrease... not by much, but it does illustrate that threads in the cache do release at least some memory when they are destroyed.

If you see a significant decrease, you may have found your problem. If you don't, then there's one more thing that needs to happen, and how quickly it can happen depends on your environment.

If the theory holds that the other threads -- the ones currently servicing active client connections -- have significant memory allocated to them, either because of recent work in their current client session or because of work requiring a lot of memory that was done by another connection prior to them languishing in the pool, then you won't see all of the potential reduction in memory consumption until those threads are allowed to die and be destroyed. Presumably your application doesn't hold them forever, but how long it will take to know for sure whether there's a difference will depend on whether you have the option of cycling your application (dropping and reconnecting the client threads) or if you'll have to just wait for them to be dropped and reconnected over time on their own.

But... it seems like a worthwhile test. You should not see a substantial performance penalty by setting thread_cache_size to 0. Fortunately, thread_cache_size is a dynamic variable, so you can freely change it with the server running.

Best Answer

Related Solutions

MySQL – Master Binlog Corruption

Mysql – How to debug a db memory-leak causing thesql to go before it’s own limits

Related Question