InnoDB/XtraDB Page Compression

Overview

Page compression is an alternative way to compress your tables which is different (but similar) to the InnoDB COMPRESSED storage format. In page compression, only uncompressed pages are stored in the buffer pool. This approach differs significantly from legacy InnoDB compressed tables using row_format=compressed, where both uncompressed and compressed pages can be in the buffer pool. In page compression, pages are actually compressed just before being written to the filespace. Similarly, pages are uncompressed when they are read from tablespace before being placed in the buffer pool. Additionally, page compression supports different compression algorithms, not only zlib. For the moment, the only engines that fully support page compression are XtraDB and InnoDB. Page compression is available only if innodb-file-format=Barracuda and innodb-file-per-table=1.

Page compression can be used on any file system but is most beneficial on SSDs and Non-Volatile Memory (NVM) devices like FusionIO atomic-series http://www.fusionio.com/products/atomic-series/. Page compression design also works with double-write enabled, but best performance is reached if double-write is disabled (i.e. innodb-doublewrite=0) and atomic writes are enabled (innodb-use-atomic-writes=1). This naturally requires that the used file system and storage device supports atomic writes (https://blog.mariadb.org/mariadb-introduces-atomic-writes/).

Choosing compression algorithm

You specify which compression algorithm to use with the --innodb-compression-algorithm= startup option for MariaDB. The options are:

Because all of these compression methods are not available by default on all distributions and MariaDB server does not bundle them, you may need to download the desired compression method package from the above links, install the package and finally recompile MariaDB server from the source distribution with:

cmake .
make
make install

After the first command above, please check that cmake has found the desired compression method from your system.

The compression method can be changed whenever needed. Currently the compression method is global (i.e. you can't specify compression method/table).

set global innodb_compression_algorithm=lz4;

From this point on page compressed tables will use the lz4 compression method. This setting does not change already compressed pages that were compressed with a different compression method. This is because MariaDB supports pages that are uncompressed, compressed with e.g. lzo and compressed with e.g. lz4 in same tablespace. This is possible because every page in InnoDB tablespace contains compression method information on page header metadata.

Choosing compression level

You specify the default compression level to use with the --innodb-compression-level= startup option for MariaDB. Values are 0-9, default is 6. Note that not all compression methods allow choosing the compression level and in those cases the compression level value is ignored.

Creating compressed tables

Only tables that are specified to be compressed are actually compressed,. You can create a page compressed table with:

create table users(user_id int not null, b name varchar(200), primary key(user_id)) 
  engine=innodb page_compressed=1;

Persistent TRIM

Normally InnoDB always writes the full page i.e. by default 16K (innodb-page-size). However, when compression is used you may use a different approach. On file systems that support fallocate() and creating sparse files (e.g. ext3/4, xfs, nvmfs, etc) by using FALLOC_FL_PUNCH_HOLE, InnoDB will only write the actual compressed page size aligned to sector size. The rest of the page is trimmed using fallocate(file_handle, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, file_offset, remainder_len);. This is needed because InnoDB always reads the full page size (default 16K).

This feature can be configured by using innodb_use_trim and innodb_use_fallocate:

innodb_use_trim=ON
innodb_use_fallocate=ON

Note that innodb_use_trim should currently only be used with NVMFS (see InnoDB holepunch compression vs the filesystem in MariaDB 10.1).

Multi-threaded flush

Normally MariaDB uses a single thread to flush dirty pages out of the buffer pool. However, when compression is used and the system has multiple-cores/CPUs and a fast I/O device (like an NVM device), you may benefit by using the multi-threaded flush mechanism. This feature has two configuration variables at startup time:

--innodb-use-mtflush= startup option for MariaDB to enable multi-threaded flush. By default this is 8. You may configure the number of used threads by --innodb-mtflush-threads. The maximum is currently 64. In multi-core systems a value similar to innodb-buffer-pool-instances that is close to the number of cores have shown to be effective. Naturally, you should benchmark the suitable value using your own application as a workload.

Monitoring compression

SHOW STATUS contains new status variables that can be used to monitor compression

XtraBackup

Note that XtraBackup (as of 2.2.12) will not work with MariaDB 10.1 compression.

Links

• https://blog.mariadb.org/significant-performance-boost-with-new-mariadb-page-compression-on-fusionio/
• https://mariadb.com/kb/en/mariadb/fusion-io-directfs-atomic-write-support/
• https://blog.mariadb.org/mariadb-introduces-atomic-writes/
• https://www.usenix.org/conference/inflow14/workshop-program/presentation/das

Thanks

• Table compression was developed with cooperation by Fusion-io http://fusionio.com and especially Dhananjoy Das and Torben Mathiasen.

See also

• InnoDB holepunch compression vs the filesystem in MariaDB 10.1