性能对比

测试环境

PolarDB MySQL版集群

Redis读写分离版实例

测试客户端

测试内容

创建数据库表到Tair的映射

mysql -h XXX -P XXX -u XXX -pXXX -e "create database if not exists XXX"

# Create mapping for string type
mysql -h XXX -P XXX -u XXX -pXXX -e "insert into mysql.tair_string_containers values ('sbtest', 'XXX', 'sbtest1', 'id', 'myfield', 'primary')"

# Create mapping for hash type
mysql -h XXX -P XXX -u XXX -pXXX -e "insert into mysql.tair_hash_containers values ('sbtest', 'XXX', 'sbtest1', 'id', 'myfield', 'primary')"

# flush tair after creating the mapping to make the mapping work
mysql -h XXX -P XXX -u XXX -pXXX -e "flush tair"

测试场景

场景一：三种节点读查询性能对比

• 场景描述：对比相同数据的情况下，Redis、PolarDB MySQL版的普通只读节点、PolarDB MySQL版的Tair缓存节点三者的读查询性能。

• 测试数据概况：测试数据长度分别为16、128、256字节，数据量均为1,000,000条。

场景二：不同缓存命中率下性能对比

• 场景描述：对比不同缓存命中率（0%、50%、75%、100%）下，PolarDB MySQL版的Tair缓存节点的读查询性能。

• 测试数据概况：命中率通过控制数据量来实现。

  • 无数据，但查询key的范围在[1, 1000000]，此时即命中率为0%。

  • 数据key的范围在[1, 500000]，查询key的范围在[1, 1000000]，使用随机读的方式进行测试，此时即命中率为50%。

  • 数据key的范围在[1, 750000]，查询key的范围在[1, 1000000]，使用随机读的方式进行测试，此时即命中率为75%。

  • 数据key的范围在[1, 1000000]，查询key的范围在[1, 1000000]，使用随机读的方式进行测试，此时即命中率为100%。

场景三：开启和关闭SCC下性能对比

• 场景描述：对比PolarDB MySQL版开启和关闭SCC（全局一致性（高性能模式））功能的情况下，Tair缓存节点的读查询性能。

• 测试数据概况：给主节点施加UPDATE压力，同时给Tair缓存节点施加GET压力，分别对比开启和关闭SCC功能下的数据一致性。

测试工具

memtier_benchmark

由于PolarDB MySQL版中表经过映射后，在Tair缓存节点中的key的格式为mapping_name@col_value，因此本文使用开源Redis的memtier_benchmark工具对Redis和PolarDB MySQL版Tair缓存节点进行压测。memtier_benchmark工具支持自定义key的前缀。

安装

docker pull redislabs/memtier_benchmark:latest

使用

# test GET command
docker run --rm redislabs/memtier_benchmark:latest -h XXX -a XXX:XXX --distinct-client-seed --key-maximum=XXX --key-minimum=1 -n 100000 --ratio=0:1 --threads=24 --clients=4 --key-prefix='sbtest@' --data-size=XXX --print-percentiles 95,99 --hide-histogram

# test HGET command
docker run --rm redislabs/memtier_benchmark:latest -h XXX -a XXX:XXX --distinct-client-seed --key-maximum=XXX --key-minimum=1  -n 100000 --threads=24 --clients=4 --key-prefix='sbtest@' --data-size=XXX --command "hget __key__ myfield"  --print-percentiles 95,99 --hide-histogram

参数说明：

Sysbench

使用Sysbench工具对PolarDB MySQL版的主节点和普通只读节点进行压测。

安装

yum -y install make automake libtool pkgconfig libaio-devel
yum -y install mariadb-devel openssl-devel
./autogen.sh
./configure
make -j
make install

使用

# for read 
sysbench --db-driver=mysql --mysql-host=XXX --mysql-port=XXX --mysql-user=XXX --mysql-password=XXX --mysql-db=XXX --table_size=XXX --tables=1 --events=0 --threads=96 --time=XXX --point_selects=1 my_oltp_read_only --value-length=XXX run 

# for update
sysbench --db-driver=mysql --mysql-host=XXX --mysql-port=XXX --mysql-user=XXXX --mysql-password=XXX --mysql-db=XXX --table_size=XXX --tables=1 --events=0 --threads=96 --rate=XXX update --non_index_updates=1 --value-length=XXX --time=XXX run

参数说明：

为了达到测试目的，本测试中对Sysbench自带的脚本进行了一定的调整：

• 修改了Sysbench自带的oltp_read_only脚本，以满足自定义数据的长度。具体如下：

require("oltp_common")

local new_options = {
    value_length = {"Value length", 16},
}

for k, v in pairs(new_options) do
    sysbench.cmdline.options[k] = v
end

sysbench.cmdline.commands.prepare = {
    function ()
       local drv = sysbench.sql.driver()
       local con = drv:connect()

       for i = sysbench.tid % sysbench.opt.threads + 1, sysbench.opt.tables,
       sysbench.opt.threads do
         create_table(drv, con, i)
       end
    end,
   sysbench.cmdline.PARALLEL_COMMAND
}

function create_table(drv, con, table_num)
    engine_def = "/*! ENGINE = " .. sysbench.opt.mysql_storage_engine .. " */"
    query = string.format([[
CREATE TABLE sbtest%d(
    id INTEGER NOT NULL AUTO_INCREMENT,
    myfield TEXT NOT NULL,
    PRIMARY KEY (`id`)
    ) %s %s]], table_num, sysbench.opt.value_length, engine_def, sysbench.opt.create_table_options)

    con:query(query)

    if (sysbench.opt.table_size > 0) then
        print(string.format("Inserting %d records into 'sbtest%d'",
                          sysbench.opt.table_size, table_num))
    end


    value_template = string.rep("#", sysbench.opt.value_length)

    query = "INSERT INTO sbtest" .. table_num .. "(myfield) VALUES"
    con:bulk_insert_init(query)

    for i = 1, sysbench.opt.table_size do
        value = sysbench.rand.string(value_template)
        query = string.format("('%s')", value)
        con:bulk_insert_next(query)
    end

    con:bulk_insert_done()
end


function prepare_statements()
   prepare_for_each_table("point_selects")
end

local t = sysbench.sql.type
local stmt_defs = {
   point_selects = {
      "SELECT myfield FROM sbtest%u WHERE id=?",
      t.INT},
}

function prepare_for_each_table(key)
    for t = 1, sysbench.opt.tables do
        sql = string.format(stmt_defs[key][1], t)
        stmt[t][key] = con:prepare(sql)

        local nparam = #stmt_defs[key] - 1

        if nparam > 0 then
            param[t][key] = {}
        end

        for p = 1, nparam do
            local btype = stmt_defs[key][p+1]
            local len

            if type(btype) == "table" then
                len = btype[2]
                btype = btype[1]
            end
            if btype == sysbench.sql.type.VARCHAR or
                btype == sysbench.sql.type.CHAR then
                param[t][key][p] = stmt[t][key]:bind_create(btype, len)
            else
                param[t][key][p] = stmt[t][key]:bind_create(btype)
            end
        end

        if nparam > 0 then
            stmt[t][key]:bind_param(unpack(param[t][key]))
        end
    end
end

function event()
   execute_point_selects()
   check_reconnect()
end

• 在SCC开启和关闭的测试对比场景下，本测试修改了Sysbench自带的oltp_update_non_index脚本，从而实现向主节点施加UPDATE压力：

require("oltp_common")

local new_options = {
    value_length = {"Value length", 16},
}

for k, v in pairs(new_options) do
    sysbench.cmdline.options[k] = v
end


function prepare_statements()
   prepare_for_each_table("non_index_updates")
end

local t = sysbench.sql.type
local stmt_defs = {
   non_index_updates = {
      "UPDATE sbtest%u SET myfield=? WHERE id=?",
      {t.VARCHAR, 256}, t.INT},
}

function prepare_for_each_table(key)
    for t = 1, sysbench.opt.tables do
        sql = string.format(stmt_defs[key][1], t)
        stmt[t][key] = con:prepare(sql)

        local nparam = #stmt_defs[key] - 1

        if nparam > 0 then
            param[t][key] = {}
        end

        for p = 1, nparam do
            local btype = stmt_defs[key][p+1]
            local len

            if type(btype) == "table" then
                len = btype[2]
                btype = btype[1]
            end
            if btype == sysbench.sql.type.VARCHAR or
                btype == sysbench.sql.type.CHAR then
                param[t][key][p] = stmt[t][key]:bind_create(btype, len)
            else
                param[t][key][p] = stmt[t][key]:bind_create(btype)
            end
        end

        if nparam > 0 then
            stmt[t][key]:bind_param(unpack(param[t][key]))
        end
    end
end

local function get_id()
   return sysbench.rand.default(1, sysbench.opt.table_size)
end


function execute_non_index_updates()
   local tnum = 1

   value_template = string.rep("#", sysbench.opt.value_length)
   for i = 1, sysbench.opt.non_index_updates do
      param[tnum].non_index_updates[1]:set_rand_str(value_template)
      param[tnum].non_index_updates[2]:set(get_id())

      stmt[tnum].non_index_updates:execute()
   end
end


function event()
   execute_non_index_updates()
   check_reconnect()
end

测试指标

测试结果

场景一：三种节点读查询性能对比

String数据结构

Hash数据结构

场景二：不同缓存命中率下性能对比

场景三：开启和关闭SCC下性能对比