oceanbase
/
oceanbase-doc
mirror of https://github.com/oceanbase/oceanbase-doc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

delete

This commit is contained in:
ylz01380183 2023-05-11 16:54:02 +08:00
parent 74516c2358
commit 569d5a0001
6 changed files with 0 additions and 1922 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

631
zh-CN/5.administrator-guide/9.performance-tuning-guide/6.performance-whitepaper/1.run-the-tpc-h-benchmark-on-oceanbase-database.md
View File

@ -1,631 +0,0 @@
# OceanBase 数据库 TPC-H 测试
## 什么是 TPC-H
TPC-H（商业智能计算测试）是美国交易处理效能委员会（TPC，Transaction Processing Performance Council）组织制定的用来模拟决策支持类应用的一个测试集。目前，学术界和工业界普遍采用 TPC-H 来评价决策支持技术方面应用的性能。这种商业测试可以全方位评测系统的整体商业计算综合能力，对厂商的要求更高，同时也具有普遍的商业实用意义，目前在银行信贷分析和信用卡分析、电信运营分析、税收分析、烟草行业决策分析中都有广泛的应用。
TPC-H 基准测试由 TPC-D（由 TPC 于 1994 年制定的标准，用于决策支持系统方面的测试基准）发展而来的。TPC-H 用 3NF 实现了一个数据仓库，共包含 8 个基本关系，其主要评价指标是各个查询的响应时间，即从提交查询到结果返回所需时间。TPC-H 基准测试的度量单位是每小时执行的查询数（QphH@size），其中 H 表示每小时系统执行复杂查询的平均次数，size 表示数据库规模的大小，它能够反映出系统在处理查询时的能力。TPC-H 是根据真实的生产运行环境来建模的，这使得它可以评估一些其他测试所不能评估的关键性能参数。总而言之，TPC 组织颁布的TPC-H 标准满足了数据仓库领域的测试需求，并且促使各个厂商以及研究机构将该项技术推向极限。
## 本文概述
本文讲介绍如何基于 OceanBase 社区版进行 TPC-H 测试，本文提供 2 种方式进行 TPC-H 性能测试。
* 基于 OBDeployer 一键进行 TPC-H 测试。
* 基于 TPC 官方 tpc-h 工具手动 step by step 进行 TPC-H 测试。
## 环境准备
测试前请按照如下要求准备您的测试环境：
* JDK：建议使用 1.8u131 及以上版本
* make：yum install make
* gcc：yum install gcc
* mysql-devel：yum install mysql-devel
* Python 连接数据库的驱动：sudo yum install MySQL-python
* prettytable：pip install prettytable
* JDBC：建议使用mysql-connector-java-5.1.47版本
* tpch tool：点击 [下载地址](https://www.tpc.org/tpc_documents_current_versions/download_programs/tools-download-request5.asp?bm_type=TPC-H&bm_vers=3.0.0&mode=CURRENT-ONLY) 获取，如果使用 OBD 一键测试，可以跳过该工具
* OBClient：详细信息，请参考 [OBClient 文档](https://github.com/oceanbase/obclient/blob/master/README.md)
* OceanBase 数据库：详细信息，请参考 [使用 OBD 部署 OceanBase 数据库](../../../4.installation-and-deployment/2.local-deployment/4.deploy-OceanBase-database-of-multi-node-cluster.md)
* iops：建议磁盘 iops 在 10000 以上
* 租户规格：
使用OBD 创建租户, OBD 创建租户时, 默认会将集群中所有的剩余资源用来创建新租户. 详情操作, 请参考 [创建租户](https://github.com/oceanbase/obdeploy/blob/master/docs/zh-CN/3.user-guide/3.obd-command/1.cluster-command-groups.md#obd-cluster-tenant-create)
```
obd cluster tenant create mytest -n tpch_mysql
```
> **注意**
>
> * 也可以使用sql 来进行创建租户, 类似下文, 在下文中的租户规格是基于 [OceanBase TPC-H 性能测试报告](2.tpc-h-benchmark-report-of-oceanbase-database.md) 中的硬件配置进行配置的，您需根据自身数据库的硬件配置进行动态调整。详细操作，请参考 [修改租户](../../6.basic-database-management/4.manage-tenants-1/4.manage-tenants-2/2.modify-tenant.md)。
```sql
create resource unit tpch_unit max_cpu 26, memory_size '70g';
create resource pool tpch_pool unit = 'tpch_unit', unit_num = 1, zone_list=('zone1','zone2','zone3');
create tenant tpch_mysql resource_pool_list=('tpch_pool'), zone_list('zone1', 'zone2', 'zone3'), primary_zone=RANDOM, locality='F@zone1,F@zone2,F@zone3' set variables ob_compatibility_mode='mysql', ob_tcp_invited_nodes='%';
```
>
> * 部署集群时，建议不要使用 `OBD cluster autodeploy` 命令，该命令为了保证稳定性，不会最大化资源利用率（例如不会使用所有内存），建议单独对配置文件进行调优，最大化资源利用率。
## 部署集群
1. 本次测试需要用到 4 台机器，TPC-H 和 OBD 单独部署在一台机器上，作为客户端的压力机器。通过 OBD 部署 OceanBase 集群需要使用 3 台机器，OceanBase 集群规模为 1:1:1。
> **说明**
>
> 在 TPC-H 测试中，部署 TPC-H 和 OBD 的机器只需 4 核 16G 即可。
2. 部署成功后，新建执行 TPC-H 测试的租户及用户（sys 租户是管理集群的内置系统租户，请勿直接使用 sys 租户进行测试）。将租户的 `primary_zone` 设置为 `RANDOM`。`RANDOM` 表示新建表分区的 Leader 随机到这 3 台机器。
## OBD 一键测试
```bash
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/oceanbase/OceanBase.repo
sudo yum install obtpch
sudo ln -s /usr/tpc-h-tools/tpc-h-tools/ /usr/local/
obd test tpch obperf --tenant=tpch_mysql -s 100 --remote-tbl-dir=/tmp/tpch100
```
### 注意
* obd 运行 tpch，详细参数介绍请参考 [obd test tpch](https://www.oceanbase.com/docs/community-obd-cn-10000000000768424)。
* 在本例中，大幅参数使用的是默认参数，在用户场景下，可以根据自己的具体情况做一些参数上的调整。例如，在本例中使用的集群名为 `obperf`，租户名是 `tpch_mysql`。
* 使用 OBD 进行一键测试时，集群的部署必须是由 OBD 进行安装和部署，否则无法获取集群的信息，将导致无法根据集群的配置进行性能调优。
* 如果系统租户的密码通过终端登陆并修改，非默认空值，则需要您先在终端中将密码修改为默认值，之后通过 [obd cluster edit-config](https://www.oceanbase.com/docs/community-obd-cn-10000000000768422) 命令在配置文件中为系统租户设置密码，配置项是 `# root_password: # root user password`。在 `obd cluster edit-config` 命令执行结束后，您还需执行 `obd cluster reload` 命令使修改生效。
* 运行 `obd test tpch` 后，系统会详细列出运行步骤和输出，数据量越大耗时越久。
* `remote-tbl-dir` 远程目录具备足够的容量能存储 tpch 的数据，建议单独一块盘存储加载测试数据。
* `obd test tpch` 命令会自动完成所有操作，无需其他额外任何操作，包含测试数据的生成、传送、OceanBase 参数优化、加载和测试。当中间环节出错时，您可参考 [obd test tpch](https://www.oceanbase.com/docs/community-obd-cn-10000000000768424) 进行重试。例如：跳过数据的生成和传送，直接进行加载和测试。
## 手动进行 TPC-H 测试
以下内容为基于 TPC 官方 tpc-h 工具进行手动 step by step 进行 TPC-H 测试，非使用 OBD 工具一键测试。手动测试可以帮助更好的学习和了解 OceanBase，尤其是一些参数的设置。
### 进行环境调优
请在系统租户下进行环境调优。
1. OceanBase 数据库调优。
在系统租户下执行 `obclient -h$host_ip -P$host_port -uroot@sys -A` 命令。
```sql
alter system set enable_sql_audit=False;
alter system set enable_sql_extension=True tenant=<your tenant name>;
alter system set syslog_level='PERF';
alter system set max_syslog_file_count=100;
alter system set trace_log_slow_query_watermark='100s';
alter system set _hash_area_size='3g' tenant=<your tenant name>;
alter system set enable_rebalance=False;
alter system set memory_chunk_cache_size=0;
alter system set ob_enable_batched_multi_statement=True tenant=<your tenant name>;
alter system set _bloom_filter_ratio=10;
alter system set _rowsets_enabled=True tenant=<your tenant name>;
alter system set _parallel_server_sleep_time=10;
alter system set cpu_quota_concurrency=4;
alter system set syslog_io_bandwidth_limit='30m';
alter system set enable_async_syslog=True;
alter system set large_query_worker_percentage=10;
alter system set builtin_db_data_verify_cycle=0;
alter system set micro_block_merge_verify_level=0;
alter system set freeze_trigger_percentage=50;
alter system set enable_perf_event=False;
alter system set large_query_threshold='1s';
# 存储下压和向量化设置后，如果非第一次设置，一定要刷新 plan cache 才生效
alter system flush plan cache global;
```
2. 设置租户。
在测试用户下执行 `obclient -h$host_ip -P$host_port -u$user@$tenant -p$password -A` 命令。
```sql
set global ob_sql_work_area_percentage = 80;
set global ob_query_timeout = 36000000000;
set global ob_trx_timeout = 36000000000;
set global max_allowed_packet = 67108864;
# parallel_servers_target = max_cpu * server_num * 8
set global parallel_servers_target = 624;
set global _groupby_nopushdown_cut_ratio = 1;
# 由于安全原因，只能使用observer本地client变更secure_file_priv
set global secure_file_priv = '';
```
3. 调优参数设置完毕后请执行 `obd cluster restart $cluster_name` 命令重启集群。
### 安装 TPC-H Tool
1. 下载 TPC-H Tool。详细信息请参考 [TPC-H Tool 下载页面](https://www.tpc.org/tpc_documents_current_versions/download_programs/tools-download-request5.asp?bm_type=TPC-H&bm_vers=3.0.0&mode=CURRENT-ONLYY)。
2. 下载完成后解压文件，进入 TPC-H 解压后的目录。
```bash
[wieck@localhost ~] $ unzip 7e965ead-8844-4efa-a275-34e35f8ab89b-tpc-h-tool.zip
[wieck@localhost ~] $ cd TPC-H_Tools_v3.0.0
```
3. 复制 `makefile.suite`。
```bash
[wieck@localhost TPC-H_Tools_v3.0.0] $ cd dbgen/
[wieck@localhost dbgen] $ cp makefile.suite Makefile
```
4. 修改 `Makefile` 文件中的 CC、DATABASE、MACHINE、WORKLOAD 等参数定义。
```bash
[wieck@localhost dbgen] $ vim Makefile
CC = gcc
# Current values for DATABASE are: INFORMIX, DB2, TDAT (Teradata)
# SQLSERVER, SYBASE, ORACLE, VECTORWISE
# Current values for MACHINE are: ATT, DOS, HP, IBM, ICL, MVS,
# SGI, SUN, U2200, VMS, LINUX, WIN32
# Current values for WORKLOAD are: TPCH
DATABASE= MYSQL
MACHINE = LINUX
WORKLOAD = TPCH
```
5. 修改 `tpcd.h` 文件，并添加新的宏定义。
```bash
[wieck@localhost dbgen] $ vim tpcd.h
#ifdef MYSQL
#define GEN_QUERY_PLAN ""
#define START_TRAN "START TRANSACTION"
#define END_TRAN "COMMIT"
#define SET_OUTPUT ""
#define SET_ROWCOUNT "limit %d;\n"
#define SET_DBASE "use %s;\n"
#endif
```
6.编译文件。
```bash
make
```
### 生成数据
您可以根据实际环境生成 TCP-H 10G、100G 或者 1T 数据。本文以生成 100G 数据为例。
```bash
./dbgen -s 100
mkdir tpch100
mv *.tbl tpch100
```
### 生成查询 SQL
> **说明**
>
> 您可参考本节中的下述步骤生成查询 SQL 后进行调整，也可直接使用 [GitHub](https://github.com/oceanbase/obdeploy/tree/master/plugins/tpch/3.1.0/queries) 中给出的查询 SQL。
>
> 若您选择使用 GitHub 中的查询 SQL，您需将 SQL 语句中的 `cpu_num` 修改为实际并发数。
1. 复制 `qgen` 和 `dists.dss` 文件至 `queries` 目录。
```bash
cp qgen queries
cp dists.dss queries
```
2. 在 `queries` 目录下创建 `gen.sh` 脚本生成查询 SQL。
```bash
[wieck@localhost queries] $ vim gen.sh
#!/usr/bin/bash
for i in {1..22}
do
./qgen -d $i -s 100 > db"$i".sql
done
```
3. 执行 `gen.sh` 脚本。
```bash
chmod +x gen.sh
./gen.sh
```
4. 查询 SQL 进行调整。
```bash
dos2unix *
```
调整后的查询 SQL 请参考 [GitHub](https://github.com/oceanbase/obdeploy/tree/master/plugins/tpch/3.1.0/queries)。您需将 GitHub 给出的 SQL 语句中的 `cpu_num` 修改为实际并发数。建议并发数的数值与可用 CPU 总数相同，两者相等时性能最好。
您可在 sys 租户下使用如下命令查看租户的可用 CPU 总数。
```sql
select sum(cpu_capacity_max) from __all_virtual_server;
```
以 q1 为例，修改后的 SQL 如下：
```SQL
select /*+ parallel(96) */ ---增加 parallel 并发执行
l_returnflag,
l_linestatus,
sum(l_quantity) as sum_qty,
sum(l_extendedprice) as sum_base_price,
sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
avg(l_quantity) as avg_qty,
avg(l_extendedprice) as avg_price,
avg(l_discount) as avg_disc,
count(*) as count_order
from
lineitem
where
l_shipdate <= date '1998-12-01' - interval '90' day
group by
l_returnflag,
l_linestatus
order by
l_returnflag,
l_linestatus;
```
### 新建表
创建表结构文件 `create_tpch_mysql_table_part.ddl`。
```sql
drop table if exists lineitem;
drop table if exists orders;
drop table if exists partsupp;
drop table if exists part;
drop table if exists customer;
drop table if exists supplier;
drop table if exists nation;
drop table if exists region;
drop tablegroup if exists tpch_tg_lineitem_order_group;
drop tablegroup if exists tpch_tg_partsupp_part;
create tablegroup if not exists tpch_tg_lineitem_order_group binding true partition by key 1 partitions cpu_num;
create tablegroup if not exists tpch_tg_partsupp_part binding true partition by key 1 partitions cpu_num;
drop table if exists lineitem;
create table lineitem (
l_orderkey BIGINT NOT NULL,
l_partkey BIGINT NOT NULL,
l_suppkey INTEGER NOT NULL,
l_linenumber INTEGER NOT NULL,
l_quantity DECIMAL(15,2) NOT NULL,
l_extendedprice DECIMAL(15,2) NOT NULL,
l_discount DECIMAL(15,2) NOT NULL,
l_tax DECIMAL(15,2) NOT NULL,
l_returnflag char(1) DEFAULT NULL,
l_linestatus char(1) DEFAULT NULL,
l_shipdate date NOT NULL,
l_commitdate date DEFAULT NULL,
l_receiptdate date DEFAULT NULL,
l_shipinstruct char(25) DEFAULT NULL,
l_shipmode char(10) DEFAULT NULL,
l_comment varchar(44) DEFAULT NULL,
primary key(l_orderkey, l_linenumber))row_format = condensed
tablegroup = tpch_tg_lineitem_order_group
partition by key (l_orderkey) partitions cpu_num;
drop table if exists orders;
create table orders (
o_orderkey bigint not null,
o_custkey bigint not null,
o_orderstatus char(1) default null,
o_totalprice bigint default null,
o_orderdate date not null,
o_orderpriority char(15) default null,
o_clerk char(15) default null,
o_shippriority bigint default null,
o_comment varchar(79) default null,
primary key (o_orderkey))row_format = condensed
tablegroup = tpch_tg_lineitem_order_group
partition by key(o_orderkey) partitions cpu_num;
drop table if exists partsupp;
create table partsupp (
ps_partkey bigint not null,
ps_suppkey bigint not null,
ps_availqty bigint default null,
ps_supplycost bigint default null,
ps_comment varchar(199) default null,
primary key (ps_partkey, ps_suppkey))row_format = condensed
tablegroup tpch_tg_partsupp_part
partition by key(ps_partkey) partitions cpu_num;
drop table if exists part;
create table part (
p_partkey bigint not null,
p_name varchar(55) default null,
p_mfgr char(25) default null,
p_brand char(10) default null,
p_type varchar(25) default null,
p_size bigint default null,
p_container char(10) default null,
p_retailprice bigint default null,
p_comment varchar(23) default null,
primary key (p_partkey))row_format = condensed
tablegroup tpch_tg_partsupp_part
partition by key(p_partkey) partitions cpu_num;
drop table if exists customer;
create table customer (
c_custkey bigint not null,
c_name varchar(25) default null,
c_address varchar(40) default null,
c_nationkey bigint default null,
c_phone char(15) default null,
c_acctbal bigint default null,
c_mktsegment char(10) default null,
c_comment varchar(117) default null,
primary key (c_custkey))row_format = condensed
partition by key(c_custkey) partitions cpu_num;
drop table if exists supplier;
create table supplier (
s_suppkey bigint not null,
s_name char(25) default null,
s_address varchar(40) default null,
s_nationkey bigint default null,
s_phone char(15) default null,
s_acctbal bigint default null,
s_comment varchar(101) default null,
primary key (s_suppkey))row_format = condensed
partition by key(s_suppkey) partitions cpu_num;
drop table if exists nation;
create table nation (
n_nationkey bigint not null,
n_name char(25) default null,
n_regionkey bigint default null,
n_comment varchar(152) default null,
primary key (n_nationkey))row_format = condensed;
drop table if exists region;
create table region (
r_regionkey bigint not null,
r_name char(25) default null,
r_comment varchar(152) default null,
primary key (r_regionkey))row_format = condensed;
```
### 加载数据
您可以根据上述步骤生成的数据和 SQL 自行编写脚本。加载数据示例操作如下：
1. 创建加载脚本目录。
```bash
[wieck@localhost dbgen] $ mkdir load
[wieck@localhost dbgen] $ cd load
[wieck@localhost load] $ cp xx/create_tpch_mysql_table_part.ddl ./
```
2. 创建 `load.py` 脚本。
```python
[wieck@localhost load] $ vim load.py
#!/usr/bin/env python
#-*- encoding:utf-8 -*-
import os
import sys
import time
import commands
hostname='$host_ip' # 注意！！请填写某个 observer，如 observer A 所在服务器的 IP 地址
port='$host_port' # observer A 的端口号
tenant='$tenant_name' # 租户名
user='$user' # 用户名
password='$password' # 密码
data_path='$path' # 注意！！请填写 observer A 所在服务器下 tbl 所在目录
db_name='$db_name' # 数据库名
# 创建表
cmd_str='obclient -h%s -P%s -u%s@%s -p%s -D%s < create_tpch_mysql_table_part.ddl'%(hostname,port,user,tenant,password,db_name)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str='obclient -h%s -P%s -u%s@%s -p%s -D%s -e "show tables;" '%(hostname,port,user,tenant,password,db_name)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/customer.tbl' into table customer fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/lineitem.tbl' into table lineitem fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/nation.tbl' into table nation fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/orders.tbl' into table orders fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -D%s -e "load data /*+ parallel(80) */ infile '%s/partsupp.tbl' into table partsupp fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/part.tbl' into table part fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/region.tbl' into table region fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
cmd_str=""" obclient -h%s -P%s -u%s@%s -p%s -c -D%s -e "load data /*+ parallel(80) */ infile '%s/supplier.tbl' into table supplier fields terminated by '|';" """ %(hostname,port,user,tenant,password,db_name,data_path)
result = commands.getstatusoutput(cmd_str)
print result
```
3. 加载数据。
> **注意**
>
> 加载数据需要安装 obclient 客户端。
```python
$ python load.py
(0,'')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.\nTABLE_NAME\nT1\nLINEITEM\nORDERS\nPARTSUPP\nPART\nCUSTOMER\nSUPPLIER\nNATION\nREGION')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
(0, 'obclient: [Warning] Using a password on the command line interface can be insecure.')
```
4. 执行合并。
Major 合并将当前大版本的 SSTable 和 MemTable 与前一个大版本的全量静态数据进行合并，使存储层统计信息更准确，生成的执行计划更稳定。
> **注意**
>
> 执行合并需要使用 sys 租户登录。
```sql
MySQL [(none)]> use oceanbase
Database changed
MySQL [oceanbase]> alter system major freeze tenant=<your tenant name>;
Query OK, 0 rows affected
```
5. 查看合并是否完成。
```sql
MySQL [oceanbase]> select FROZEN_SCN, LAST_SCN from oceanbase.CDB_OB_MAJOR_COMPACTION;
+---------------------+---------------------+
| FROZEN_SCN | LAST_SCN |
+---------------------+---------------------+
| 1667239201167716767 | 1667239201167716767 |
| 1667239200111919300 | 1667239200111919300 |
| 1667239201167452168 | 1667239201167452168 |
| 1667239201168053124 | 1667239201168053124 |
| 1667239201167520213 | 1667239201167520213 |
+---------------------+---------------------+
```
所有的 `FROZEN_SCN` 和 `LAST_SCN` 的值相等即表示合并完成。
6. 手动收集统计信息
在测试用户下执行 `obclient -h$host_ip -P$host_port -u$user@$tenant -p$password -A -D$database` 命令。
```sql
set _force_parallel_query_dop = 96;
analyze table lineitem partition(lineitem) compute statistics for all columns size auto;
analyze table orders partition(orders) compute statistics for all columns size auto;
analyze table partsupp partition(partsupp) compute statistics for all columns size auto;
analyze table part partition(part) compute statistics for all columns size auto;
analyze table customer partition(customer) compute statistics for all columns size auto;
analyze table supplier partition(supplier) compute statistics for all columns size auto;
analyze table nation compute statistics for all columns size auto;
analyze table region compute statistics for all columns size auto;
```
> **说明**
>
> `_force_parallel_query_dop` 可以设置当前 session 上的 query 并发度，取值为 cpu_num。
### 执行测试
您可以根据上述步骤生成的数据和 SQL 自行编写脚本。执行测试示例操作如下：
1. 在 `queries` 目录下编写测试脚本 `tpch.sh`。
```bash
[wieck@localhost queries] $ vim tpch.sh
#!/bin/bash
TPCH_TEST="obclient -h $host_ip -P $host_port -utpch_100g_part@tpch_mysql -D tpch_100g_part -ptest -c"
# warmup预热
for i in {1..22}
do
sql1="source db${i}.sql"
echo $sql1| $TPCH_TEST >db${i}.log || ret=1
done
# 正式执行
for i in {1..22}
do
starttime=`date +%s%N`
echo `date '+[%Y-%m-%d %H:%M:%S]'` "BEGIN Q${i}"
sql1="source db${i}.sql"
echo $sql1| $TPCH_TEST >db${i}.log || ret=1
stoptime=`date +%s%N`
costtime=`echo $stoptime $starttime | awk '{printf "%0.2f\n", ($1 - $2) / 1000000000}'`
echo `date '+[%Y-%m-%d %H:%M:%S]'` "END,COST ${costtime}s"
done
```
2. 执行测试脚本。
```bash
sh tpch.sh
```
> **说明**
>
> 测试结果可参考 [OceanBase TPC-H 性能测试报告](2.tpc-h-benchmark-report-of-oceanbase-database.md)。
## FAQ
* 导入数据失败。报错信息如下：
```bash
ERROR 1017 (HY000) at line 1: File not exist
```
tbl 文件必须放在所连接的 OceanBase 数据库所在机器的某个目录下，因为加载数据必须本地导入。
* 查看数据报错。报错信息如下：
```bash
ERROR 4624 (HY000)：No memory or reach tenant memory limit
```
内存不足，建议增大租户内存。
* 导入数据报错。报错信息如下：
```bash
ERROR 1227 (42501) at line 1: Access denied
```
需要授予用户访问权限。运行以下命令，授予权限：
```bash
grant file on *.* to tpch_100g_part;
```
* 查询 SQL 进行调整 dos2unix * 时报错，报错信息如下：
```bash
-bash: dos2unix: command not found
```
需要安装 dos2unix。执行以下命令，即可安装：
```bash
yum install -y dos2unix
```

64
zh-CN/5.administrator-guide/9.performance-tuning-guide/6.performance-whitepaper/2.tpc-h-benchmark-report-of-oceanbase-database.md
View File

@ -1,64 +0,0 @@
# OceanBase TPC-H 性能测试报告
## 测试环境 (阿里云 ECS）
* 3 节点硬件配置
| 服务类型 | ECS 类型 | 实例数 | 机器核心数 | 内存 |
|---------------|----------------|-----|------|------|
| OceanBase 数据库 | ecs.g7.8xlarge | 3 | 32C | 128G |
| TPC-H | ecs.g7.8xlarge | 1 | 32C | 128G |
* 3 节点租户规格
```sql
create resource unit tpch_unit max_cpu 26, memory_size '70g'
create resource pool tpch_pool unit = 'tpch_unit', unit_num = 1, zone_list=('zone1','zone2','zone3');
create tenant tpch_mysql resource_pool_list=('tpch_pool'), zone_list('zone1', 'zone2', 'zone3'), primary_zone=RANDOM, locality='F@zone1,F@zone2,F@zone3' set variables ob_compatibility_mode='mysql', ob_tcp_invited_nodes='%';
```
* 软件版本
| 服务类型 | 软件版本 |
|---------------|--------------------------------------|
| OceanBase 数据库 | OceanBase_CE 4.0.0.0 |
| TPC-H | V3.0.0 |
| OS | CentOS Linux release 7.9.2009 (Core) |
## 测试方案
* 使用 OBD 部署 OceanBase 数据库集群。TPC-H 客户端需要部署在一台机器上, 作为客户端的压力机器。您无需部署 ODP，测试时直连任意一台机器即可。
* 3 节点的 OceanBase 集群部署规模为 1：1：1。部署成功后先新建跑 TPCH 测试的租户及用户（sys 租户是管理集群的内置系统租户，请勿直接使用 sys 租户进行测试），设置租户的 `primary_zone` 为 RANDOM。
* 测试数据量：100G。
* 测试步骤详见 [OceanBase 数据库 TPC-H 测试](../6.performance-whitepaper/1.run-the-tpc-h-benchmark-on-oceanbase-database.md)。
## 测试结果
| **Query ID** |**3节点 OBServer V4.0.0_CE** **查询响应时间（单位：秒）** |
|--------------|-----------------------------------------------------------|
|Q1 |2.34 |
|Q2 |0.14 |
|Q3 |0.72 |
|Q4 |0.56 |
|Q5 |2.25 |
|Q6 |0.23 |
|Q7 |1.52 |
|Q8 |0.7 |
|Q9 |5.22 |
|Q10 |1.24 |
|Q11 |0.23 |
|Q12 |1.62 |
|Q13 |2.41 |
|Q14 |0.36 |
|Q15 |0.79 |
|Q16 |0.66 |
|Q17 |0.63 |
|Q18 |0.93 |
|Q19 |0.78 |
|Q20 |1.17 |
|Q21 |2.42 |
|Q22 |1.24 |
|Total |28.16 |

381
zh-CN/5.administrator-guide/9.performance-tuning-guide/6.performance-whitepaper/3.use-sysbench-to-test-the-performance-of-oceanbase-database.md
View File

@ -1,381 +0,0 @@
# OceanBase 数据库 Sysbench 测试
本文介绍如何使用 Sysbench 测试对 OceanBase 数据库的 OLTP 性能进行测试。在本文中使用 2 种方式，对 OceanBase 运行 Sysbench 测试：
* 通过 OBD test 命令一键进行 Sysbench 测试。
* 基于官方 Sysbench 工具手动 step by step 进行测试。
## 什么是 Sysbench
Sysbench 是一个基于 LuaJIT 的可编写脚本的多线程基准测试工具，可以执行 CPU、内存、线程、IO 和数据库等方面的性能测试，常用于评估测试各种不同系统参数下的数据库负载情况，不需要修改源码，通过自定义 lua 脚本就可以实现不同业务类型的测试。Sysbench 主要包括以下几种测试：
* CPU 性能
* 磁盘 IO 性能
* 调度程序性能
* 内存分配及传输速度
* POSIX 线程性能
* 数据库性能（OLTP 基准测试）
## 环境准备
* JDK：建议使用 1.8u131 及以上版本
* make：yum install make
* automake：yum install automake
* autoconf：yum install autoconf
* libtool：yum install libtool
* gcc：yum install gcc
* mariadb-devel：yum install mariadb-devel mariadb
* JDBC：建议使用 mysql-connector-java-5.1.47 版本
* Sysbench：建议使用 1.0 及以上版本
* OBClient ：详细信息，参考 [OBClient 文档](https://github.com/oceanbase/obclient/blob/master/README.md)
> **注意**
>
> 当使用的 OBClient 版本大于等于 2.2.0 时，会默认开启 ob20 协议以及全链路追踪的能力，在 sysbench 测试中会影响性能，建议通过设置环境变量手动关闭：`export ENABLE_PROTOCOL_OB20=0`
* OceanBase 数据库：建议单独部署 ODP。详细信息，参考 [使用 OBD 部署 OceanBase 数据库](../../../4.installation-and-deployment/2.local-deployment/4.deploy-OceanBase-database-of-multi-node-cluster.md)
* iops：建议磁盘 iops 在 10000 以上
* 租户规格：
```sql
create resource unit sysbench_unit max_cpu 26, memory_size '70g';
create resource pool sysbench_pool unit = 'sysbench_unit', unit_num = 1, zone_list=('zone1','zone2','zone3');
create tenant sysbench_tenant resource_pool_list=('sysbench_pool'), zone_list('zone1', 'zone2', 'zone3'), primary_zone=RANDOM, locality='F@zone1,F@zone2,F@zone3' set variables ob_compatibility_mode='mysql', ob_tcp_invited_nodes='%';
```
> **注意**
>
> * 上文的租户规格是基于 [OceanBase Sysbench 性能测试报告](4.sysbench-benchmark-report-of-oceanbase-database.md) 中的硬件配置进行配置的，您需根据自身数据库的硬件配置进行动态调整。详细操作请参考 [修改租户](../../6.basic-database-management/4.manage-tenants-1/4.manage-tenants-2/2.modify-tenant.md)。
>
> * 部署集群时，建议不要使用 `OBD cluster autodeploy` 命令，该命令为了保证稳定性，不会最大化资源利用率（例如不会使用所有内存），建议单独对配置文件进行调优，最大化资源利用率。
## 测试方案
1. 本次测试需要用到 4 台机器，Sysbench、ODP 和 OBD 单独部署在一台机器上，作为客户端的压力机器。通过 OBD 部署 OceanBase 集群需要使用 3 台机器，OceanBase 集群规模为 1:1:1。
> **说明**
>
> 在 Sysbench 测试中，部署 Sysbench、ODP 和 OBD 的机器有一定的灵活性，根据 OBServer 总核数的不同分为以下三种情况：
>
> * 当 OBServer 总核数小于等于 47 核时，该机器仅需要 8 核 64G 即可。
>
> * 当 OBServer 总核数在 48 核和 72 核之间时，该机器需要 16 核 128G。
>
> * 当 OBServer 总核数大于等于 73 核时，该机器需要 32 核 128G。
2. 部署成功后先新建进行 Sysbench 测试的租户及用户（sys 租户是管理集群的内置系统租户，请勿直接使用 sys 租户进行测试），设置租户的 `primary_zone` 为 RANDOM，RANDOM 表示新建表分区的 leader 随机到这 3 台机器。
3. 通过 Sysbench 导入 30 张表，每张表有 100 万行数据。
4. 启动 Sysbench 客户端，进行 `point_select`、`read_write`、`read_only` 和 `write_only` 测试。
5. 每轮测试 `--time` 设置为 60s，线程数取值可以为 `32/64/128/256/512/1024` 等。
## OBD 一键测试
添加一脚本 ob_sysbench.sh
```shell
#!/bin/bash
echo "run oltp_read_only test"
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_only.lua --table-size=1000000 --threads=32 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_only.lua --table-size=1000000 --threads=64 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_only.lua --table-size=1000000 --threads=128 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_only.lua --table-size=1000000 --threads=256 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_only.lua --table-size=1000000 --threads=512 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_only.lua --table-size=1000000 --threads=1024 --rand-type=uniform
echo "run oltp_write_only test"
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_write_only.lua --table-size=1000000 --threads=32 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_write_only.lua --table-size=1000000 --threads=64 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_write_only.lua --table-size=1000000 --threads=128 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_write_only.lua --table-size=1000000 --threads=256 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_write_only.lua --table-size=1000000 --threads=512 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_write_only.lua --table-size=1000000 --threads=1024 --rand-type=uniform
echo "run oltp_read_write test"
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_write.lua --table-size=1000000 --threads=32 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_write.lua --table-size=1000000 --threads=64 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_write.lua --table-size=1000000 --threads=128 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_write.lua --table-size=1000000 --threads=256 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_write.lua --table-size=1000000 --threads=512 --rand-type=uniform
obd test sysbench <deploy_name> --tenant=<tenant_name> --script-name=oltp_read_write.lua --table-size=1000000 --threads=1024 --rand-type=uniform
```
其中 `deploy_name` 为部署集群的名称，`tenant_name` 为租户名称，您需根据实际情况进行修改。
```bash
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/oceanbase/OceanBase.repo
sudo yum install ob-sysbench
./ob_sysbench.sh
```
### 注意
* 使用 OBD 运行 Sysbench 的详细参数介绍请参考命令 [obd test sysbench](https://www.oceanbase.com/docs/community-obd-cn-10000000000768424)。
* 使用 OBD 进行一键测试时，集群的部署必须是由 OBD 进行安装和部署，否则无法获取集群的信息，将导致无法根据集群的配置进行性能调优。
* 如果系统租户的密码通过终端登陆并修改，非默认空值，则需要您先在终端中将密码修改为默认值，之后通过 [obd cluster edit-config](https://www.oceanbase.com/docs/community-obd-cn-10000000000768422) 命令在配置文件中为系统租户设置密码，配置项是 `# root_password: # root user password`。在 `obd cluster edit-config` 命令执行结束后，您还需执行 [obd cluster reload](https://www.oceanbase.com/docs/community-obd-cn-10000000000768422) 使修改生效。
* 运行 `obd test sysbench` 后，系统会详细列出运行步骤和输出，数据量越大耗时越久。
* `obd test sysbench` 会自动完成所有操作，无需其他额外任何操作，包含测试数据的生成、OceanBase 参数优化、加载和测试。当中间环节出错时可以参考命令 [obd test sysbench](https://www.oceanbase.com/docs/community-obd-cn-10000000000768424) 进行重试，例如可以跳过数据的生成直接进行加载和测试。
## 手动进行 Sysbench 测试
### 测试规格
```shell
--mysql-db=test
--table_size=1000000
--tables=30
--threads=32/64/128/256/512/1024
--report-interval=10
--time=60
--db-ps-mode=disable
--rand-type=uniform
```
### 安装 Sysbench
按照以下步骤安装 Sysbench。
1. 下载 Sysbench。
详细信息参考 [Sysbench 下载地址](https://github.com/akopytov/sysbench/releases/tag/1.0.20)。
2. 解压 Sysbench。
```bash
unzip ./1.0.20.zip
```
3. 编译 Sysbench。
进入 Sysbench 解压后的目录，运行以下命令编译 Sysbench：
```bash
[wieck@localhost ~] $ cd sysbench-1.0.20
[wieck@localhost sysbench-1.0.20] $./autogen.sh
[wieck@localhost sysbench-1.0.20] $./configure --prefix=/usr/sysbench/ --with-mysql-includes=/usr/include/mysql/ --with-mysql-libs=/usr/lib64/mysql/ --with-mysql
[wieck@localhost sysbench-1.0.20] $make
[wieck@localhost sysbench-1.0.20] $make install
[wieck@localhost sysbench-1.0.20] $cp -r /usr/sysbench/share/sysbench/* /usr/sysbench/bin/
```
参数说明：
| 参数名 | 说明 |
|-----------------------|-----------------------|
| --prefix | 指定 Sysbench 的安装目录。 |
| --with-mysql-includes | 指定 mysql 的 includes 目录。 |
| --with-mysql-libs | 指定 mysql 的 lib 目录。 |
| --with-mysql | Sysbench 默认支持 MySQL |
4. 运行以下命令，验证 Sysbench 是否安装成功：
```bash
[wieck@localhost sysbench-1.0.20] $./src/sysbench --help
```
如果返回以下信息，则 Sysbench 安装成功。
```bash
Usage:
sysbench [options]... [testname] [command]
Commands implemented by most tests: prepare run cleanup help
```
### 环境调优
在执行 Sysbench 测试前，您需要对 OceanBase 数据库进行简单的设置，以发挥其最大性能。
1. OBServer调优（sys 租户登录设置）
在系统租户下执行 `obclient -h$host_ip -P$host_port -uroot@sys -A` 命令。
```sql
alter system set enable_sql_audit=false;
alter system set enable_early_lock_release=true tenant=<your tenant name>;
alter system set memory_chunk_cache_size=0;
alter system set syslog_io_bandwidth_limit='30m';
alter system set enable_async_syslog=true;
alter system set large_query_worker_percentage=10;
alter system set builtin_db_data_verify_cycle=0;
alter system set micro_block_merge_verify_level=0;
alter system set large_query_threshold='200s';
alter system set trace_log_slow_query_watermark='10s';
alter system set server_permanent_offline_time='36000s';
alter system set _ob_get_gts_ahead_interval='1ms';
alter system set bf_cache_priority=10;
alter system set user_block_cache_priority=5;
alter system set syslog_level='PERF';
alter system set enable_perf_event=False;
alter system set plan_cache_evict_interval='30s';
alter system set bf_cache_miss_count_threshold=1;
alter system set _enable_defensive_check=False;
alter system set _rowsets_enabled=false tenant=<your tenant name>;
alter system set _enable_newsort=false;
alter system set _trace_control_info='' tenant=<your tenant name>;
alter system set _lcl_op_interval='0ms';
alter system set ob_enable_batched_multi_statement=True tenant=<your tenant name>;
alter system set writing_throttling_trigger_percentage=100 tenant=<your tenant name>;
```
2. ODP 调优（sys 租户登录设置）
在系统租户下执行 `obclient -h$host_ip -P$host_port -uroot@sys -A` 命令。
```sql
alter proxyconfig set enable_prometheus=False;
alter proxyconfig set enable_metadb_used=False;
alter proxyconfig set enable_standby=False;
alter proxyconfig set enable_strict_stat_time=False;
alter proxyconfig set use_local_dbconfig=True;
alter proxyconfig set enable_compression_protocol=False;
alter proxyconfig set enable_ob_protocol_v2=False;
```
3. 设置租户（进行测试的用户登录设置）
在测试用户下执行 `obclient -h$host_ip -P$host_port -u$user@$tenant -p$password -A` 命令。
```sql
set global ob_query_timeout = 3600000000;
set global ob_trx_timeout = 3600000000;
set global max_allowed_packet = 67108864;
set global ob_sql_work_area_percentage = 100;
# parallel_servers_target = max_cpu * server_num * 8
set global parallel_servers_target = 624;
set global binlog_row_image = 'MINIMAL';
```
4. 调优参数设置完毕后请执行 `obd cluster restart $cluster_name` 命令重启集群。
### 操作步骤
按照以下步骤进行 Sysbench 测试：
1. 运行以下命令，初始化数据库：
```bash
/usr/sysbench/bin/sysbench oltp_read_write.lua --mysql-host=x.x.x.x --mysql-port=xxxx --mysql-db=test --mysql-user=$user@$tenant --mysql-password=xxx --table_size=1000000 --tables=30 --threads=150 --report-interval=10 --rand-type=uniform --time=60 cleanup
```
2. 运行以下命令，新建表：
```bash
/usr/sysbench/bin/sysbench oltp_read_write.lua --mysql-host=x.x.x.x --mysql-port=xxxx --mysql-db=test --mysql-user=$user@$tenant --mysql-password=test --table_size=1000000 --tables=30 --threads=150 --report-interval=10 --rand-type=uniform --time=60 prepare
```
3. 运行以下命令，执行测试：
```bash
/usr/sysbench/bin/sysbench oltp_read_write.lua --mysql-host=x.x.x.x --mysql-port=xxxx --mysql-db=test --mysql-user=$user@$tenant --mysql-password=xxx --table_size=1000000 --tables=30 --threads=150 --report-interval=10 --time=60 --rand-type=uniform --db-ps-mode=disable run
```
参数说明：
| 参数名 | 说明 |
|-------------------|-------------------------------------------------------------------------------------|
| --mysql-host | 运行 OceanBase 数据库机器的 IP。如果有 ODP 建议使用 ODP 的 IP。 |
| --mysql-port | 端口号。 |
| --mysql-db | 待连接的数据库。 |
| --mysql-user | 用户名。 |
| --mysql-password | 密码。 |
| --table_size | 每张表初始化的数据数量。 |
| --tables | 初始化表的数量。 |
| --threads | 启动的线程数量。 |
| --time | 运行时间。设置为 `0` 时表示不限制时间。 |
| --report-interval | 运行期间日志，单位为秒。 |
| --events | 最大请求数量，定义数量后可以不需要 --time 选项。 |
| --rand-type | 访问数据时使用的随机生成函数。取值可以为 `special`、`uniform`、`gaussian` 或 `pareto`。 默认值为 `special`， 早期值为 `uniform`。 |
| --skip_trx=on | 在只读测试中打开或关闭事务。默认打开。 |
| --percentile=N | 打印百分位 rt，默认值为 `95`。 |
| oltp_write_only | 在 Sysbench 的 lua 目录下，自带有针对不同场景的测试用例，比如 insert 和 point_select 等。 |
> **说明**
>
> 测试结果可参考 [OceanBase Sysbench 性能测试报告](4.sysbench-benchmark-report-of-oceanbase-database.md)。
## FAQ
* 安装 Sysbench 失败。报错信息如下：
```bash
automake 1.10.x (aclocal) wasn't found, exiting
```
操作系统没有安装 Automake。运行以下命令安装 Automake：
```bash
yum install automake.noarch
```
* 安装 Sysbench 失败。报错信息如下：
```bash
libtoolize 1.4+ wasn't found, exiting
```
操作系统没有安装 Libtool。运行以下命令安装 Libtool：
```bash
yum install libtool
```
* 安装 Sysbench 失败。报错信息如下：
```bash
drv_mysql.c:35:19: fatal error: mysql.h: No such file or directory
```
操作系统没有安装 MySQL 的 lib 库。运行以下命令安装：
```bash
yum install mysql-community-devel.x86_64
```
* 安装 Sysbench 失败。报错信息如下：
```bash
cannot find MySQL client libraries in /usr/lib/mysql/
```
执行以下命令查找 MySQL 的 lib 库。可能位于 `/usr/lib64/mysql`。
```bash
find /usr -name mysql
```
* 在 Sysbench 和 OceanBase 数据库配置均合理的情况下，性能还是很差。
1. Sysbench 是对 CPU、内存、网络非常敏感的测试。如果客户端和目标测试数据库不在一个局域网中，网络延迟可能会影响 Sysbench 性能。
2. 与 OceanBase 数据库集群使用了 ODP 有关，可以先对单个 OceanBase 数据库进程进行高并发压力测试，将结果和使用 ODP 的场景对比。
3. 建议将 ODP 和 Sysbench 单独部署在同一台机器上，通过 ODP 进行 Sysbench 测试。
* 在高并发压力下，为什么系统的 CPU 利用率依然很低？
虽然整体 CPU 偏低，但是部分模块的 CPU 可能达到很高的利用率。

95
zh-CN/5.administrator-guide/9.performance-tuning-guide/6.performance-whitepaper/4.sysbench-benchmark-report-of-oceanbase-database.md
View File

@ -1,95 +0,0 @@
# OceanBase Sysbench 性能测试报告
## 测试环境 (阿里云 ECS）
* 硬件配置
| 服务类型 | ECS 类型 | 实例数 | 机器核心数 | 内存 |
|---------------|------------------|-----|------|------|
| OceanBase 数据库 | ecs.hfg7.8xlarge | 3 | 32C | 128G |
| ODP、Sysbench | ecs.hfg7.8xlarge | 1 | 32C | 128G |
* 租户规格
```sql
create resource unit sysbench_unit max_cpu 26, memory_size '70g'
create resource pool sysbench_pool unit = 'sysbench_unit', unit_num = 1, zone_list=('zone1','zone2','zone3');
create tenant sysbench_tenant resource_pool_list=('sysbench_pool'), zone_list('zone1', 'zone2', 'zone3'), primary_zone=RANDOM, locality='F@zone1,F@zone2,F@zone3' set variables ob_compatibility_mode='mysql', ob_tcp_invited_nodes='%';
```
* 软件版本
| 服务类型 | 软件版本 |
|---------------|--------------------------------------|
| OceanBase 数据库 | OceanBase_CE 4.0.0.0 |
| ODP | OceanBase 4.0.0 |
| Sysbench | 1.0.20 |
| OS | CentOS Linux release 7.9.2009 (Core) |
## 测试方案
1. 通过 OBD 部署 OceanBase 集群，ODP 和 Sysbench 单独部署在一台机器上, 作为客户端的压力机器。
2. OceanBase 集群规模为 1：1：1，部署成功后先新建跑 Sysbench 测试的租户及用户（sys 租户是管理集群的内置系统租户，请勿直接使用 sys 租户进行测试），设置租户的 `primary_zone` 为 RANDOM，RANDOM 表示新建表分区的 leader 随机到这 3 台机器。
3. 启动 Sysbench 客户端，进行 `point_select`、`read_write`、`read_only` 和 `write_only` 测试。
4. 每轮测试 `--time` 设置为 60s，线程数取值可以为 `32/64/128/256/512/1024`。
### 测试规格
```shell
--mysql-db=test
--table_size=1000000
--tables=30
--threads=32/64/128/256/512/1024
--report-interval=10
--time=60
--db-ps-mode=disable
--rand-type=uniform
```
## 测试结果
### Point Select 性能
| Threads | V4.0.0_CE QPS | V4.0.0_CE 95% Latency (ms) |
|---------|--------------------------|---------------------------------------|
| 32 | 180360.71 | 0.21 |
| 64 | 312254.88 | 0.26 |
| 128 | 473423.04 | 0.41 |
| 256 | 571193.03 | 0.89 |
| 512 | 604975.51 | 2.97 |
| 1024 | 614351.07 | 4.33 |
### Read Only 性能
| Threads | V4.0.0_CE QPS | V4.0.0_CE 95% Latency (ms) |
|---------|--------------------------|---------------------------------------|
| 32 | 124009.84 | 5.47 |
| 64 | 222034.29 | 5.88 |
| 128 | 355395.57 | 7.04 |
| 256 | 453947.58 | 12.30 |
| 512 | 524999.55 | 20.74 |
| 1024 | 510261.3 | 70.55 |
### Write Only 性能
| Threads | V4.0.0_CE QPS | V4.0.0_CE 95% Latency (ms) |
|---------|-------------------------|---------------------------------------|
| 32 | 37798.74 | 6.43 |
| 64 | 72534.26 | 6.67 |
| 128 | 125263.17 | 7.70 |
| 256 | 188289.15 | 10.84 |
| 512 | 239281.86 | 18.95 |
| 1024 | 285313.68 | 34.95 |
### Read Write 性能
| Threads | V4.0.0_CE QPS | V4.0.0_CE 95% Latency (ms) |
|---------|--------------------------|----------------------------------------|
| 32 | 68305.00 | 11.65 |
| 64 | 123581.29 | 12.98 |
| 128 | 203527.24 | 16.71 |
| 256 | 276437.9 | 25.74 |
| 512 | 319334.46 | 48.34 |
| 1024 | 314807.75 | 147.61 |

691
zh-CN/5.administrator-guide/9.performance-tuning-guide/6.performance-whitepaper/5.run-the-tpc-c-benchmark-on-oceanbase-database.md
View File

@ -1,691 +0,0 @@
# OceanBase 数据库 TPC-C 测试
## 什么是 TPC-C
TPC-C 是一个对 OLTP（联机交易处理）系统进行测试的规范，使用一个商品销售模型对 OLTP 系统进行测试。详细信息，参考 [TPC-C 中文简介](https://github.com/domino-succ/tpcc-hbase/wiki/%E4%B8%AD%E6%96%87-TPC-C%E7%AE%80%E4%BB%8B)。
## 环境准备
* JDK：建议使用 1.8u131 及以上版本。
* JDBC：建议使用 mysql-connector-java-5.1.47 版本，其他版本可能存在语法兼容性问题。
* Ant：建议使用 apache-ant-1.10 及以上版本。
* Benchmark SQL：建议使用 Benchmark SQL 5.0。
* OBClient：详细信息，参考 [OBClient 文档](https://github.com/oceanbase/obclient/blob/master/README.md)。
* OceanBase 数据库：建议单独部署 ODP。详细信息，参考 [在线部署 OceanBase 数据库](../../../4.installation-and-deployment/2.local-deployment/4.deploy-OceanBase-database-of-multi-node-cluster.md)。
* iops：建议磁盘 iops 在 10000 以上。
* 租户规格：
```sql
create resource unit tpcc_unit max_cpu 26, memory_size '70g';
create resource pool tpcc_pool unit = 'tpcc_unit', unit_num = 1, zone_list=('zone1','zone2','zone3');
create tenant tpcc_tenant resource_pool_list=('tpcc_pool'), zone_list('zone1', 'zone2', 'zone3'), primary_zone=RANDOM, locality='F@zone1,F@zone2,F@zone3' set variables ob_compatibility_mode='mysql', ob_tcp_invited_nodes='%';
```
> **注意**
>
> * 上文的租户规格是基于 [OceanBase TPC-C 性能测试报告](6.tpc-c-benchmark-report-of-oceanbase-database.md) 中的硬件配置进行配置的，您需根据自身数据库的硬件配置进行动态调整。详细操作，参考 [修改租户](../../6.basic-database-management/4.manage-tenants-1/4.manage-tenants-2/2.modify-tenant.md)。
>
> * 部署集群时，建议不要使用 `OBD cluster autodeploy` 命令，该命令为了保证稳定性，不会最大化资源利用率（例如不会使用所有内存），建议单独对配置文件进行调优，最大化资源利用率。
## 测试方案
1. 本次测试需要用到 4 台机器，Benchmark SQL、ODP 和 OBD 单独部署在一台机器上，作为客户端的压力机器。通过 OBD 部署 OceanBase 集群需要使用 3 台机器，OceanBase 集群规模为 1:1:1。
> **说明**
>
> 在 TPC-C 测试中，部署 Benchmark SQL、ODP 和 OBD 的机器有一定的灵活性，根据 OBServer 总核数的不同分为以下三种情况：
>
> * 当 OBServer 总核数小于等于 47 核时，该机器仅需要 8 核 64G 即可。
>
> * 当 OBServer 总核数在 48 核和 72 核之间时，该机器需要 16 核 128G。
>
> * 当 OBServer 总核数大于等于 73 核时，该机器需要 32 核 128G。
2. 部署成功后，新建执行 TPC-C 测试的租户及用户（sys 租户是管理集群的内置系统租户，请勿直接使用 sys 租户进行测试）。将租户的 `primary_zone` 设置为 `RANDOM`。`RANDOM` 表示新建表分区的 Leader 随机到这 3 台机器。
### 测试规格
```shell
warehouses=1000
loadWorkers=40
terminals=600
runMins=5
newOrderWeight=45
paymentWeight=43
orderStatusWeight=4
deliveryWeight=4
stockLevelWeight=4
```
## OBD 一键测试
```bash
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/oceanbase/OceanBase.repo
sudo yum install obtpcc java
obd test tpcc obperf --tenant=tpcc_mysql --warehouses 10 --run-mins 1
```
### 注意
* obd 运行 tpcc，详细参数介绍请参考 [obd test tpcc](https://www.oceanbase.com/docs/community-obd-cn-10000000000768424)。
* 在本例中，大幅参数使用的是默认参数，在用户场景下，可以根据自己的具体情况做一些参数上的调整。例如，在本例中使用的集群名为 `obperf`，租户名是 `tpcc_mysql`。
* 使用 OBD 进行一键测试时，集群的部署必须是由 OBD 进行安装和部署，否则无法获取集群的信息，将导致无法根据集群的配置进行性能调优。
* 如果系统租户的密码通过终端登陆并修改，非默认空值，则需要您先在终端中将密码修改为默认值，之后通过 [obd cluster edit-config](https://www.oceanbase.com/docs/community-obd-cn-10000000000768422) 命令在配置文件中为系统租户设置密码，配置项是 `# root_password: # root user password`。在 `obd cluster edit-config` 命令执行结束后，您还需执行 `obd cluster reload` 命令使修改生效。
* 运行 `obd test tpcc` 后，系统会详细列出运行步骤和输出，数据量越大耗时越久。
* `obd test tpcc` 命令会自动完成所有操作，无需其他额外任何操作，包含测试数据的生成、传送、OceanBase 参数优化、加载和测试。当中间环节出错时，您可参考 [obd test tpcc](https://www.oceanbase.com/docs/community-obd-cn-10000000000768424) 进行重试。例如：跳过数据的生成和传送，直接进行加载和测试。
## 手动进行 TPC-C 测试
### 安装 Ant
按照以下步骤安装 Ant：
1. 下载 Ant。
```bash
wget "http://archive.apache.org/dist/ant/binaries/apache-ant-1.10.6-bin.zip"
```
2. 安装 Ant
```bash
unzip apache-ant-1.10.6-bin.zip
```
3. 设置环境变量。
```bash
[admin@obtest004 ~]$ sudo vim /etc/profile
#ant
export ANT_HOME=xx/apache-ant-1.10.6
export PATH=xx/apache-ant-1.10.6/bin:$PATH
[admin@obtest004 ~]$ source /etc/profile
```
4. 检查是否安装成功。
```bash
[admin@obtest004 ~]$ant -version
```
如果返回以下信息，则安装成功。
```bash
Apache Ant(TM) version 1.10.6 compiled on May 2 2019
```
### 安装 Benchmark SQL
按照以下步骤安装 Benchmark SQL：
1. 下载 Benchmark SQL。
详细信息参考 [Benchmark SQL 下载地址](https://sourceforge.net/projects/benchmarksql/files/latest/download/)。
2. 解压 Benchmark SQL。
```bash
unzip ./benchmarksql-5.0.zip
```
3. 编译 Benchmark SQL。
进入 Benchmark SQL 解压后的目录，使用 Ant 编译 Benchmark SQL：
```bash
[admin@obtest004 ~] $ cd benchmarksql-5.0
[admin@obtest004 benchmarksql-5.0] $ ant
```
### 适配 Benchmark SQL5
由于 Benchmark SQL5 不支持 OceanBase 数据库的 TPC-C 测试，本节将详细介绍如何通过修改 BenchMarkSQL5 部分源码支持 OceanBase 数据库。
1. 修改 `benchmarksql-5.0/src/client/jTPCC.java` 文件，增加 OceanBase 数据库相关内容。
```java
if (iDB.equals("firebird"))
dbType = DB_FIREBIRD;
else if (iDB.equals("oracle"))
dbType = DB_ORACLE;
else if (iDB.equals("postgres"))
dbType = DB_POSTGRES;
else if (iDB.equals("oceanbase")) ---增加 oceanbase 数据库相关内容
dbType = DB_OCEANBASE;
else
{
log.error("unknown database type '" + iDB + "'");
return;
}
```
修改 `benchmarksql-5.0/src/client/jTPCCConfig.java` 文件，增加 OceanBase 数据库类型。
```java
public final static int
DB_UNKNOWN = 0,
DB_FIREBIRD = 1,
DB_ORACLE = 2,
DB_POSTGRES = 3,
DB_OCEANBASE = 4; ---增加 oceanbase 数据库类型
```
2. 修改 `benchmarksql-5.0/src/client/jTPCCConnection.java` 文件，在 SQL 子查询增加 "AS L" 别名。
```java
default:
stmtStockLevelSelectLow = dbConn.prepareStatement(
"SELECT count(*) AS low_stock FROM (" +
" SELECT s_w_id, s_i_id, s_quantity " +
" FROM bmsql_stock " +
" WHERE s_w_id = ? AND s_quantity < ? AND s_i_id IN (" +
" SELECT ol_i_id " +
" FROM bmsql_district " +
" JOIN bmsql_order_line ON ol_w_id = d_w_id " +
" AND ol_d_id = d_id " +
" AND ol_o_id >= d_next_o_id - 20 " +
" AND ol_o_id < d_next_o_id " +
" WHERE d_w_id = ? AND d_id = ? " +
" ) " +
" )AS L"); ---增加 "AS L" 别名
break;
```
3. 重新编译修改后的源码。
```bash
[admin@obtest004 ~]# cd benchmarksql-5.0
[admin@obtest004 benchmarksql-5.0]# ant
```
4. 在 `benchmarksql-5.0/run` 目录下，创建文件 `prop.oceanbase`。
```java
db=oceanbase
driver=com.mysql.jdbc.Driver
conn=jdbc:mysql://$host_ip:$port/$db_name?rewriteBatchedStatements=true&allowMultiQueries=true&useLocalSessionState=true&useUnicode=true&characterEncoding=utf-8&socketTimeout=30000000
//请填写完整user信息
user=$user@$tenant
password=*****
warehouses=1000
loadWorkers=40
terminals=600
database=$db_name
//To run specified transactions per terminal- runMins must equal zero
runTxnsPerTerminal=0
//To run for specified minutes- runTxnsPerTerminal must equal zero
runMins=5
//Number of total transactions per minute
limitTxnsPerMin=0
//Set to true to run in 4.x compatible mode. Set to false to use the
//entire configured database evenly.
terminalWarehouseFixed=true
//The following five values must add up to 100
//The default percentages of 45, 43, 4, 4 & 4 match the TPC-C spec
newOrderWeight=45
paymentWeight=43
orderStatusWeight=4
deliveryWeight=4
stockLevelWeight=4
// Directory name to create for collecting detailed result data.
// Comment this out to suppress.
resultDirectory=my_result_%tY-%tm-%td_%tH%tM%tS
osCollectorScript=./misc/os_collector_linux.py
osCollectorInterval=1
//osCollectorSSHAddr=user@dbhost
//osCollectorDevices=net_eth0 blk_sda
```
prop.oceanbase 中的参数说明：
* JDBC 连接串：`conn=jdbc:mysql://x.x.x.x(ip):xx(port)/xxxx(dbname)?rewriteBatchedStatements=true&allowMultiQueries=true&useLocalSessionState=true&useUnicode=true&characterEncoding=utf-8&socketTimeout=3000000`
* rewriteBatchedStatements：
* 参数非常重要，会严重影响导数据效率，不可以忽略。
* 如果导数据较慢，可以用对应租户登录上去通过 show full processlist 检查是否开启。
* new order 事务中也用到了 batch update，因此导数和 benchmark 阶段都需要开启。
* 并发数量（terminals）：600，MySQL 租户配置下并发需要结合具体配置动态调整。
* useLocalSessionState：是否使用 autocommit，read_only 和 transaction isolation 的内部值（jdbc 端的本地值），建议设置为 true，如果设置为 false，则需要发语句到远端请求，增加发送请求频次，影响性能。
* warehouses/loadWorkers 这两项用于设置压测数据量，可以适当调整。
* numTerminals \> 0 \&\& numTerminals \<= 10\*numWarehouses，terminals 的范围需要在这个区间内。
5. 修改文件：`benchmarksql-5.0/run/funcs.sh`，添加 OceanBase 数据库类型。
```shell
function setCP()
{
case "$(getProp db)" in
firebird)
cp="../lib/firebird/*:../lib/*"
;;
oracle)
cp="../lib/oracle/*"
if [ ! -z "${ORACLE_HOME}" -a -d ${ORACLE_HOME}/lib ] ; then
cp="${cp}:${ORACLE_HOME}/lib/*"
fi
cp="${cp}:../lib/*"
;;
postgres)
cp="../lib/postgres/*:../lib/*"
;;
oceanbase) ---添加 OceanBase 数据库类型
cp="../lib/oceanbase/*:../lib/*"
;;
esac
myCP=".:${cp}:../dist/*"
export myCP
}
...省略
case "$(getProp db)" in
firebird|oracle|postgres|oceanbase) ---添加 OceanBase 数据库类型
;;
"") echo "ERROR: missing db= config option in ${PROPS}" >&2
exit 1
;;
*) echo "ERROR: unsupported database type 'db=$(getProp db)' in ${PROPS}" >&2
exit 1
;;
esac
```
6. 添加 mysql java connector 驱动，推荐 mysql-connector-java-5.1.47.jar。
```bash
[admin@obtest004 benchmarksql-5.0]# mkdir lib/oceanbase/
[admin@obtest004 benchmarksql-5.0]# cp xx/mysql-connector-java-5.1.47.jar lib/oceanbase/
```
7. 修改 `benchmarksql-5.0/run/runDatabaseBuild.sh`。
```shell
AFTER_LOAD="indexCreates foreignKeys extraHistID buildFinish"
# 修改为：
AFTER_LOAD="indexCreates buildFinish"
```
8. 改造 BenchMarkSQL5 中的 SQL。
备份并重写 `benchmarksql-5.0/run/sql.common/tableCreates.sql`。
```sql
create table bmsql_config (
cfg_name varchar(30) primary key,
cfg_value varchar(50)
);
create tablegroup if not exists tpcc_group binding true partition by hash partitions 96;
create table bmsql_warehouse (
w_id integer not null,
w_ytd decimal(12,2),
w_tax decimal(4,4),
w_name varchar(10),
w_street_1 varchar(20),
w_street_2 varchar(20),
w_city varchar(20),
w_state char(2),
w_zip char(9),
primary key(w_id)
)tablegroup='tpcc_group' partition by hash(w_id) partitions 96;
create table bmsql_district (
d_w_id integer not null,
d_id integer not null,
d_ytd decimal(12,2),
d_tax decimal(4,4),
d_next_o_id integer,
d_name varchar(10),
d_street_1 varchar(20),
d_street_2 varchar(20),
d_city varchar(20),
d_state char(2),
d_zip char(9),
PRIMARY KEY (d_w_id, d_id)
)tablegroup='tpcc_group' partition by hash(d_w_id) partitions 96;
create table bmsql_customer (
c_w_id integer not null,
c_d_id integer not null,
c_id integer not null,
c_discount decimal(4,4),
c_credit char(2),
c_last varchar(16),
c_first varchar(16),
c_credit_lim decimal(12,2),
c_balance decimal(12,2),
c_ytd_payment decimal(12,2),
c_payment_cnt integer,
c_delivery_cnt integer,
c_street_1 varchar(20),
c_street_2 varchar(20),
c_city varchar(20),
c_state char(2),
c_zip char(9),
c_phone char(16),
c_since timestamp,
c_middle char(2),
c_data varchar(500),
PRIMARY KEY (c_w_id, c_d_id, c_id)
)tablegroup='tpcc_group' partition by hash(c_w_id) partitions 96;
create table bmsql_history (
hist_id integer AUTO_INCREMENT,
h_c_id integer,
h_c_d_id integer,
h_c_w_id integer,
h_d_id integer,
h_w_id integer,
h_date timestamp,
h_amount decimal(6,2),
h_data varchar(24)
)tablegroup='tpcc_group' partition by hash(h_w_id) partitions 96;
create table bmsql_new_order (
no_w_id integer not null ,
no_d_id integer not null,
no_o_id integer not null,
PRIMARY KEY (no_w_id, no_d_id, no_o_id)
)tablegroup='tpcc_group' partition by hash(no_w_id) partitions 96;
create table bmsql_oorder (
o_w_id integer not null,
o_d_id integer not null,
o_id integer not null,
o_c_id integer,
o_carrier_id integer,
o_ol_cnt integer,
o_all_local integer,
o_entry_d timestamp,
PRIMARY KEY (o_w_id, o_d_id, o_id)
)tablegroup='tpcc_group' partition by hash(o_w_id) partitions 96;
create table bmsql_order_line (
ol_w_id integer not null,
ol_d_id integer not null,
ol_o_id integer not null,
ol_number integer not null,
ol_i_id integer not null,
ol_delivery_d timestamp,
ol_amount decimal(6,2),
ol_supply_w_id integer,
ol_quantity integer,
ol_dist_info char(24),
PRIMARY KEY (ol_w_id, ol_d_id, ol_o_id, ol_number)
)tablegroup='tpcc_group' partition by hash(ol_w_id) partitions 96;
create table bmsql_item (
i_id integer not null,
i_name varchar(24),
i_price decimal(5,2),
i_data varchar(50),
i_im_id integer,
PRIMARY KEY (i_id)
) ;
create table bmsql_stock (
s_w_id integer not null,
s_i_id integer not null,
s_quantity integer,
s_ytd integer,
s_order_cnt integer,
s_remote_cnt integer,
s_data varchar(50),
s_dist_01 char(24),
s_dist_02 char(24),
s_dist_03 char(24),
s_dist_04 char(24),
s_dist_05 char(24),
s_dist_06 char(24),
s_dist_07 char(24),
s_dist_08 char(24),
s_dist_09 char(24),
s_dist_10 char(24),
PRIMARY KEY (s_w_id, s_i_id)
)tablegroup='tpcc_group' partition by hash(s_w_id) partitions 96;
```
备份并重写 `benchmarksql-5.0/run/sql.common/tableDrops.sql`。
```sql
drop table bmsql_config;
drop table bmsql_new_order;
drop table bmsql_order_line;
drop table bmsql_oorder;
drop table bmsql_history;
drop table bmsql_customer;
drop table bmsql_stock;
drop table bmsql_item;
drop table bmsql_district;
drop table bmsql_warehouse;
drop tablegroup tpcc_group;
```
备份并重写 `benchmarksql-5.0/run/sql.common/indexCreates.sql`。
```sql
create index bmsql_customer_idx1 on bmsql_customer (c_w_id, c_d_id, c_last, c_first) local;
create index bmsql_oorder_idx1 on bmsql_oorder (o_w_id, o_d_id, o_carrier_id, o_id) local;
```
备份并重写 `benchmarksql-5.0/run/sql.common/indexDrops.sql`。
```sql
alter table bmsql_customer drop index bmsql_customer_idx1;
alter table bmsql_oorder drop index bmsql_oorder_idx1;
```
### 环境调优
1. ODP 调优，请在 sys 租户下执行。
执行 `obclient -h$host_ip -P$host_port -uroot@sys -A` 命令进入系统租户。
```sql
alter proxyconfig set automatic_match_work_thread=False;
alter proxyconfig set proxy_mem_limited=4G;
alter proxyconfig set enable_compression_protocol=False;
alter proxyconfig set slow_proxy_process_time_threshold='500ms';
alter proxyconfig set enable_ob_protocol_v2=False;
alter proxyconfig set syslog_level='error'
```
2. OceanBase 数据库导数据阶段，请在 sys 租户下执行。
执行 `obclient -h$host_ip -P$host_port -uroot@sys -A` 命令进入系统租户。
```sql
alter system set enable_sql_extension=True tenant=<your tenant name>;
alter system set enable_sql_audit=false;
alter system set enable_early_lock_release=true tenant=<your tenant name>;
alter system set memory_chunk_cache_size=0;
alter system set syslog_io_bandwidth_limit='30m';
alter system set enable_async_syslog=true;
alter system set large_query_worker_percentage=10;
alter system set builtin_db_data_verify_cycle=0;
alter system set micro_block_merge_verify_level=0;
alter system set large_query_threshold='200s';
alter system set trace_log_slow_query_watermark='10s';
alter system set server_permanent_offline_time='36000s';
alter system set _ob_get_gts_ahead_interval='1ms';
alter system set bf_cache_priority=10;
alter system set user_block_cache_priority=5;
alter system set syslog_level='PERF';
alter system set enable_perf_event=False;
alter system set plan_cache_evict_interval='30s';
alter system set bf_cache_miss_count_threshold=1;
alter system set _enable_defensive_check=False;
alter system set _rowsets_enabled=false tenant=<your tenant name>;
alter system set _enable_newsort=false;
alter system set _trace_control_info='' tenant=<your tenant name>;
alter system set _lcl_op_interval='0ms';
alter system set ob_enable_batched_multi_statement=True tenant=<your tenant name>;
```
> **说明**
>
> 在测试结束后，上述参数需要进行恢复，否则在 OBD 升级时，会出现升级报错。
3. 在 OBServer 部署之后，在进行测试 TPCC 的租户下执行。
执行 `obclient -h$host_ip -P$host_port -u$user@$tenant -p$password -A` 命令进入测试租户。
```sql
set global ob_query_timeout = 3600000000;
set global ob_trx_timeout = 3600000000;
set global max_allowed_packet = 67108864;
set global ob_sql_work_area_percentage = 100;
# parallel_servers_target取max_cpu * server_num * 8
set global parallel_servers_target = 624;
set global binlog_row_image = 'MINIMAL';
# 导入数据后执行
alter system set writing_throttling_trigger_percentage=100 tenant=<your tenant name>;
```
4. 调优参数设置完毕后请执行 `obd cluster restart $cluster_name` 命令重启集群。
### 操作步骤
以下命令均在 `benchmarksql-5.0/run` 目录下执行。按照以下步骤进行 TPC-C 测试：
1. 运行以下命令，初始化环境：
```bash
./runDatabaseDestroy.sh prop.oceanbase
```
2. 运行以下命令，创建表并导入数据：
```bash
./runDatabaseBuild.sh prop.oceanbase
```
3. 执行合并（需要使用 sys 租户登录）
Major 合并将当前大版本的 SSTable 和 MemTable 与前一个大版本的全量静态数据进行合并，使存储层统计信息更准确，生成的执行计划更稳定。
```sql
MySQL [(none)]> use oceanbase
Database changed
MySQL [oceanbase]> alter system major freeze tenant=<your tenant name>;
Query OK, 0 rows affected
```
4. 查看合并是否完成
```sql
MySQL [oceanbase]> select FROZEN_SCN, LAST_SCN from oceanbase.CDB_OB_MAJOR_COMPACTION;
+---------------------+---------------------+
| FROZEN_SCN | LAST_SCN |
+---------------------+---------------------+
| 1667239201167716767 | 1667239201167716767 |
| 1667239200111919300 | 1667239200111919300 |
| 1667239201167452168 | 1667239201167452168 |
| 1667239201168053124 | 1667239201168053124 |
| 1667239201167520213 | 1667239201167520213 |
+---------------------+---------------------+
```
所有的 `FROZEN_SCN` 和 `LAST_SCN` 的值相等即表示合并完成。
5. 手动收集统计信息
执行 `obclient -h$host_ip -P$host_port -u$user@$tenant -p$password -A -D$database` 命令进入测试租户。
```sql
set _force_parallel_query_dop = 96;
analyze table bmsql_warehouse partition(bmsql_warehouse) compute statistics for all columns size auto;
analyze table bmsql_district partition(bmsql_district) compute statistics for all columns size auto;
analyze table bmsql_customer partition(bmsql_customer) compute statistics for all columns size auto;
analyze table bmsql_new_order partition(bmsql_new_order) compute statistics for all columns size auto;
analyze table bmsql_oorder partition(bmsql_oorder) compute statistics for all columns size auto;
analyze table bmsql_order_line partition(bmsql_order_line) compute statistics for all columns size auto;
analyze table bmsql_stock partition(bmsql_stock) compute statistics for all columns size auto;
analyze table bmsql_history partition(bmsql_history) compute statistics for all columns size auto;
analyze table bmsql_config compute statistics for all columns size auto;
analyze table bmsql_item compute statistics for all columns size auto;
```
> **说明**
>
> `_force_parallel_query_dop` 可以设置当前 session 上的 query 并发度，取值为 cpu_num。
6. 运行以下命令，执行压力测试：
```bash
./runBenchmark.sh prop.oceanbase
```
> **说明**
>
> 测试结果可参考 [OceanBase TPC-C 性能测试报告](6.tpc-c-benchmark-report-of-oceanbase-database.md)。
## FAQ
* 如何停止 Benchmark SQL 工具。
到期自动停止：依赖 prop.oceanbase 中 runMins 设置的值。
强行停止：ps auxf \| grep java -- 删除 Java 程删除 runBenchmark 进程。
* 找不到 main 类型。报错信息如下：
```bash
Could not find the main class: ExecJDBC. Program will exit.
```
可能原因有两个：要么升级 JDK，要么升级 JDBC 版本。运行以下命令安装 Java：
```bash
sudo yum install jdk
```
* 终端数量无效。报错信息如下：
```bash
Invalid number of terminals!
```
这是 prop.oceanbase 中设置的 terminals 值不对，需填写 numTerminals \<= 0 \|\| numTerminals \> 10\*numWarehouses 范围内的 terminals 值。
* 事务超时。报错信息如下：
```bash
transaction timeout
```
需增大超时时间，测试租户下执行 `set global ob_query_timeout=36000000000;set global ob_trx_timeout=36000000000`。

60
zh-CN/5.administrator-guide/9.performance-tuning-guide/6.performance-whitepaper/6.tpc-c-benchmark-report-of-oceanbase-database.md
View File

@ -1,60 +0,0 @@
# OceanBase TPC-C 性能测试报告
## 测试环境 (阿里云 ECS）
* 3 节点硬件配置
| 服务类型 | ECS 类型 | 实例数 | 机器核心数 | 内存 |
|---------------|----------------|-----|------|------|
| OceanBase 数据库 | ecs.g7.8xlarge | 3 | 32C | 128G |
| ODP、Benchmark SQL | ecs.g7.8xlarge | 1 | 32C | 128G |
* 3 节点租户规格
```sql
create resource unit tpcc_unit max_cpu 26, memory_size '70g'
create resource pool tpcc_pool unit = 'tpcc_unit', unit_num = 1, zone_list=('zone1','zone2','zone3');
create tenant tpcc_tenant resource_pool_list=('tpcc_pool'), zone_list('zone1', 'zone2', 'zone3'), primary_zone=RANDOM, locality='F@zone1,F@zone2,F@zone3' set variables ob_compatibility_mode='mysql', ob_tcp_invited_nodes='%';
```
* 软件版本
| 服务类型 | 软件版本 |
|---------------|--------------------------------------|
| OceanBase 数据库 | OceanBase_CE 4.0.0.0 |
| ODP | OceanBase 4.0.0 |
| Benchmark SQL | Benchmark SQL V5.0 |
| JDBC | mysql-connector-java-5.1.47 |
| OS | CentOS Linux release 7.9.2009 (Core) |
## 测试方案
1. 通过 OBD 部署 OceanBase 集群，ODP 和 TPC-C 单独部署在一台机器上, 防止客户端的压力不足成为性能瓶颈。
2. 3 节点的 OceanBase 集群部署规模为 1：1：1，部署成功后先新建跑 TPC-C 测试的租户及用户（sys 租户是管理集群的内置系统租户，请勿直接使用 sys 租户进行测试），设置租户的 `primary_zone` 为 RANDOM。
3. 测试步骤请详见：[OceanBase 数据库 TPC-C 测试](5.run-the-tpc-c-benchmark-on-oceanbase-database.md)。
### 测试规格
```shell
warehouses=1000
loadWorkers=40
terminals=800
runMins=5
newOrderWeight=45
paymentWeight=43
orderStatusWeight=4
deliveryWeight=4
stockLevelWeight=4
```
## 测试结果
* OceanBase 集群规模为 1：1：1 性能数据
```bash
[Thread-704] INFO jTPCC : Term-00, Measured tpmC (NewOrders) = 307021.0
[Thread-704] INFO jTPCC : Term-00, Measured tpmTOTAL = 682517.67
[Thread-704] INFO jTPCC : Term-00, Transaction Count = 3417638
```