:original_name: mrs_01_1017.html

.. _mrs_01_1017:

Improving Real-time Data Write Performance
==========================================

Scenario
--------

Scenarios where data needs to be written to HBase in real time, or large-scale and consecutive put scenarios

.. note::

   This section applies to MRS 3.\ *x* and later versions.

Prerequisites
-------------

The HBase put or delete interface can be used to save data to HBase.

Procedure
---------

-  **Data writing server tuning**

   Parameter portal:

   Go to the **All Configurations** page of the HBase service. For details, see :ref:`Modifying Cluster Service Configuration Parameters <mrs_01_2125>`.

   .. table:: **Table 1** Configuration items that affect real-time data writing

       
      | Parameter                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Default Value                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
       
      | hbase.wal.hsync                               | Controls the synchronization degree when HLogs are written to the HDFS. If the value is **true**, HDFS returns only when data is written to the disk. If the value is **false**, HDFS returns when data is written to the OS cache.                                                                                                                                                                                                                                                                                            | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | Set the parameter to **false** to improve write performance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.hfile.hsync                             | Controls the synchronization degree when HFiles are written to the HDFS. If the value is **true**, HDFS returns only when data is written to the disk. If the value is **false**, HDFS returns when data is written to the OS cache.                                                                                                                                                                                                                                                                                           | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | Set the parameter to **false** to improve write performance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | GC_OPTS                                       | You can increase HBase memory to improve HBase performance because read and write operations are performed in HBase memory. **HeapSize** and **NewSize** need to be adjusted. When you adjust **HeapSize**, set **Xms** and **Xmx** to the same value to avoid performance problems when JVM dynamically adjusts **HeapSize**. Set **NewSize** to 1/8 of **HeapSize**.                                                                                                                                                         | -  HMaster                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | -  **HMaster**: If HBase clusters enlarge and the number of Regions grows, properly increase the **GC_OPTS** parameter value of the HMaster.                                                                                                                                                                                                                                                                                                                                                                                   |    -server -Xms4G -Xmx4G -XX:NewSize=512M -XX:MaxNewSize=512M -XX:MetaspaceSize=128M -XX:MaxMetaspaceSize=512M -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:CMSInitiatingOccupancyFraction=65 -XX:+PrintGCDetails -Dsun.rmi.dgc.client.gcInterval=0x7FFFFFFFFFFFFFE -Dsun.rmi.dgc.server.gcInterval=0x7FFFFFFFFFFFFFE -XX:-OmitStackTraceInFastThrow -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=1M   |
      |                                               | -  **RegionServer**: A RegionServer needs more memory than an HMaster. If sufficient memory is available, increase the **HeapSize** value.                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | -  Region Server                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
      |                                               | .. note::                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |    -server -Xms6G -Xmx6G -XX:NewSize=1024M -XX:MaxNewSize=1024M -XX:MetaspaceSize=128M -XX:MaxMetaspaceSize=512M -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:CMSInitiatingOccupancyFraction=65 -XX:+PrintGCDetails -Dsun.rmi.dgc.client.gcInterval=0x7FFFFFFFFFFFFFE -Dsun.rmi.dgc.server.gcInterval=0x7FFFFFFFFFFFFFE -XX:-OmitStackTraceInFastThrow -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=1M |
      |                                               |    When the value of **HeapSize** for the active HMaster is 4 GB, the HBase cluster can support 100,000 regions. Empirically, each time 35,000 regions are added to the cluster, the value of **HeapSize** must be increased by 2 GB. It is recommended that the value of **HeapSize** for the active HMaster not exceed 32 GB.                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.regionserver.handler.count              | Indicates the number of RPC server instances started on RegionServer. If the parameter is set to an excessively large value, threads will compete fiercely. If the parameter is set to an excessively small value, requests will be waiting for a long time in RegionServer, reducing the processing capability. You can add threads based on resources.                                                                                                                                                                       | 200                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | It is recommended that the value be set to **100** to **300** based on the CPU usage.                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.hregion.max.filesize                    | Indicates the maximum size of an HStoreFile, in bytes. If the size of any HStoreFile exceeds the value of this parameter, the managed Hregion is divided into two parts.                                                                                                                                                                                                                                                                                                                                                       | 10737418240                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
       
      | hbase.hregion.memstore.flush.size             | On the RegionServer, when the size of memstore that exists in memory of write operations exceeds **memstore.flush.size**, MemStoreFlusher performs the Flush operation to write the memstore to the corresponding store in the format of HFile.                                                                                                                                                                                                                                                                                | 134217728                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | If RegionServer memory is sufficient and active Regions are few, increase the parameter value and reduce compaction times to improve system performance.                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | The Flush operation may be delayed after it takes place. Write operations continue and memstore keeps increasing during the delay. The maximum size of memstore is: **memstore.flush.size** x **hbase.hregion.memstore.block.multiplier**. When the memstore size exceeds the maximum value, write operations are blocked. Properly increasing the value of **hbase.hregion.memstore.block.multiplier** can reduce the blocks and make performance become more stable. Unit: byte                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.regionserver.global.memstore.size       | Updates the size of all MemStores supported by the RegionServer before locking or forcible flush. On the RegionServer, the MemStoreFlusher thread performs the flush. The thread regularly checks memory occupied by write operations. When the total memory volume occupied by write operations exceeds the threshold, MemStoreFlusher performs the flush. Larger memstore will be flushed first and then smaller ones until the occupied memory is less than the threshold.                                                  | 0.4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | Threshold = hbase.regionserver.global.memstore.size x hbase.regionserver.global.memstore.size.lower.limit x HBase_HEAPSIZE                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | .. note::                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |    The sum of the parameter value and the value of **hfile.block.cache.size** cannot exceed 0.8, that is, memory occupied by read and write operations cannot exceed 80% of **HeapSize**, ensuring stable running of other operations.                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.hstore.blockingStoreFiles               | Check whether the number of files is larger than the value of **hbase.hstore.blockingStoreFiles** before you flush regions.                                                                                                                                                                                                                                                                                                                                                                                                    | 15                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | If it is larger than the value of **hbase.hstore.blockingStoreFiles**, perform a compaction and configure **hbase.hstore.blockingWaitTime** to 90s to make the flush delay for 90s. During the delay, write operations continue and the memstore size keeps increasing and exceeds the threshold (**memstore.flush.size** x **hbase.hregion.memstore.block.multiplier**), blocking write operations. After compaction is complete, a large number of writes may be generated. As a result, the performance fluctuates sharply. |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | Increase the value of **hbase.hstore.blockingStoreFiles** to reduce block possibilities.                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.regionserver.thread.compaction.throttle | The compression whose size is greater than the value of this parameter is executed by the large thread pool. The unit is bytes. Indicates a threshold of a total file size for compaction during a Minor Compaction. The total file size affects execution duration of a compaction. If the total file size is large, other compactions or flushes may be blocked.                                                                                                                                                             | 1610612736                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
       
      | hbase.hstore.compaction.min                   | Indicates the minimum number of HStoreFiles on which minor compaction is performed each time. When the size of a file in a Store exceeds the value of this parameter, the file is compacted. You can increase the value of this parameter to reduce the number of times that the file is compacted. If there are too many files in the Store, read performance will be affected.                                                                                                                                               | 6                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
       
      | hbase.hstore.compaction.max                   | Indicates the maximum number of HStoreFiles on which minor compaction is performed each time. The functions of the parameter and **hbase.hstore.compaction.max.size** are similar. Both are used to limit the execution duration of one compaction.                                                                                                                                                                                                                                                                            | 10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
       
      | hbase.hstore.compaction.max.size              | If the size of an HFile is larger than the parameter value, the HFile will not be compacted in a Minor Compaction but can be compacted in a Major Compaction.                                                                                                                                                                                                                                                                                                                                                                  | 9223372036854775807                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | The parameter is used to prevent HFiles of large sizes from being compacted. After a Major Compaction is forbidden, multiple HFiles can exist in a Store and will not be merged into one HFile, without affecting data access performance. The unit is byte.                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | hbase.hregion.majorcompaction                 | Main compression interval of all HStoreFile files in a region. The unit is milliseconds. Execution of Major Compactions consumes much system resources and will affect system performance during peak hours.                                                                                                                                                                                                                                                                                                                   | 604800000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | If service updates, deletion, and reclamation of expired data space are infrequent, set the parameter to **0** to disable Major Compactions.                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | If you must perform a Major Compaction to reclaim more space, increase the parameter value and configure the **hbase.offpeak.end.hour** and **hbase.offpeak.start.hour** parameters to make the Major Compaction be triggered in off-peak hours.                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       
      | -  hbase.regionserver.maxlogs                 | -  Indicates the threshold for the number of HLog files that are not flushed on a RegionServer. If the number of HLog files is greater than the threshold, the RegionServer forcibly performs flush operations.                                                                                                                                                                                                                                                                                                                | -  32                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
      | -  hbase.regionserver.hlog.blocksize          | -  Indicates the maximum size of an HLog file. If the size of an HLog file is greater than the value of this parameter, a new HLog file is generated. The old HLog file is disabled and archived.                                                                                                                                                                                                                                                                                                                              | -  134217728                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
      |                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      |                                               | The two parameters determine the number of HLogs that are not flushed in a RegionServer. When the data volume is less than the total size of memstore, the flush operation is forcibly triggered due to excessive HLog files. In this case, you can adjust the values of the two parameters to avoid forcible flush. Unit: byte                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
       

-  **Data writing client tuning**

   It is recommended that data is written in Put List mode if necessary, which greatly improves write performance. The length of each put list needs to be set based on the single put size and parameters of the actual environment. You are advised to do some basic tests before configuring parameters.

-  **Data table writing design optimization**

   .. table:: **Table 2** Parameters affecting real-time data writing

      +-----------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------+
      | Parameter             | Description                                                                                                                                                                                                                                                              | Default Value         |
      +=======================+==========================================================================================================================================================================================================================================================================+=======================+
      | COMPRESSION           | The compression algorithm compresses blocks in HFiles. For compressible data, configure the compression algorithm to efficiently reduce disk I/Os and improve performance.                                                                                               | NONE                  |
      |                       |                                                                                                                                                                                                                                                                          |                       |
      |                       | .. note::                                                                                                                                                                                                                                                                |                       |
      |                       |                                                                                                                                                                                                                                                                          |                       |
      |                       |    Some data cannot be efficiently compressed. For example, a compressed figure can hardly be compressed again. The common compression algorithm is SNAPPY, because it has a high encoding/decoding speed and acceptable compression rate.                               |                       |
      +-----------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------+
      | BLOCKSIZE             | Different block sizes affect HBase data read and write performance. You can configure sizes for blocks in an HFile. Larger blocks have a higher compression rate. However, they have poor performance in random data read, because HBase reads data in a unit of blocks. | 65536                 |
      |                       |                                                                                                                                                                                                                                                                          |                       |
      |                       | Set the parameter to 128 KB or 256 KB to improve data write efficiency without greatly affecting random read performance. The unit is byte.                                                                                                                              |                       |
      +-----------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------+
      | IN_MEMORY             | Whether to cache table data in the memory first, which improves data read performance. If you will frequently access some small tables, set the parameter.                                                                                                               | false                 |
      +-----------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------+
