openGauss数据库源码解析系列文章——AI技术（一）

AI技术最早可以追溯到20世纪50年代，甚至比数据库系统的发展历史还要悠久。但是，由于各种各样客观因素的制约，在很长的一段时间内，人工智能技术并没有得到大规模的应用，甚至还经历了几次明显的低谷期。随着信息技术的进一步发展，从前限制人工智能发展的因素已经逐渐减弱，所谓的ABC（artificial intelligence、big data、cloud computing）技术也应运而生。人工智能在某些领域的能力已经超过了人类，如AlphaGo战胜了人类的顶尖围棋选手事件、无处不在的“刷脸”验证、语音助手使人们看到人工智能在更多领域落地的可能。

在本章中，将介绍openGauss在人工智能与数据库结合领域的探索，包括自调优、智能索引推荐等领域的内容。

一、概述

数据库与AI相遇会摩擦出什么样的火花？近些年全球各大公司、顶尖高校都在尝试将AI与数据库融合。openGauss目前也已经取得了阶段性的成果，部分项目也已经在华为云上线并进行商用。openGauss在人工智能领域的探索可以分为两个主要方向：AI4DB与DB4AI。

（1） AI4DB就是指用AI使能数据库，从而获得数据库更好的执行表现、实现数据库系统的自治、免运维等。主要包括自调优、自诊断、自安全、自运维、自愈等子领域。

（2） DB4AI就是指打通数据库到人工智能应用的端到端流程，统一人工智能技术栈，达到AI应用的开箱即用、高性能、低成本等目的。例如通过类SQL语句使用推荐系统、图像检索、时序预测等功能，充分发挥openGauss高并行、列存储等优势，提高机器学习任务的执行效率。同时，在数据侧实现AI计算，还可以降低数据的网络传输成本，实现本地化计算、节省人力、降低成本。

下述2-6章节介绍AI4DB功能，7章节介绍DB4AI功能。

数据库自调优技术是一个比较大的范畴，通常包括对数据库参数配置、自身代价优化模型的调优等。本节主要介绍对数据库参数配置进行自动调优的功能。

1. 基于规则

基于规则的参数调优是比较简单、通用的方法，通过对人工调优的经验进行整理，编写成各式各样的规则来对数据库系统进行调优。该方法的优点是速度快、可解释性好、稳定性高，缺点是规则随着系统的变化可能会不再适用、推荐的参数往往不是最优的。著名的采用该方法的工具为MySQKTuner-perl。

假设数据库系统只需要调一个参数，且这个参数与性能之间的关系又非常简单（如二者呈线性相关、变化曲线呈二次函数关系），则可以通过二分搜索算法查找出最优的参数值。那么试想：如果系统需要调整多个参数，这些参数彼此之间又互相影响，这时应该如何去调优呢？显然，这不是通过二分法就可以解决的了，这在数学上属于一个组合优化问题，即在有限的对象集（此处指所有参数自由组合后的可能结果集）中找出最优对象（此时是最优参数配置）的问题。对于组合优化问题，一般的解法包括近似算法（approximation algorithm）、启发式算法（heuristic algorithm）、遗传算法等。由于启发式算法实现相对简单，结果比较稳定，因而广泛应用。如参数优化方法bestconf就属于此类。基于启发式算法的参数调优方法具有应用场景普遍、优化效果稳定的特点，一般不需要根据系统的变化而进行算法的重新适配，但是每次启动都需要重新探索、不能够重复利用历史探索经验、而且往往容易陷入局部最优。相关搜索算法在其他参数调优领域也有较多的实践，如AutoML中对机器学习算法超参数的调优。

3. 基于监督学习

监督学习（supervised learning）是一种通过显式地输入特征向量和结果标签，寻找二者之间映射关系的一种机器学习算法。它可以根据训练数据学习或建立一个模型，并基于此模型推测新的实例。如果监督学习模型的输出是连续的值则称为回归分析，如果预测一个分类标签则称为分类。

如果可以人为地建立数据库系统的特征（如workload特征、硬件环境特征等），并提供在该特征下的最优参数，那么就可以通过上述数据拟合出一个模型，并据此推测出新的数据库系统上何种参数最优。

该方法的优点是一旦训练好模型，推荐新参数的过程将非常快，缺点是训练模型比较复杂（需要收集大量的数据，这些数据本身就不是很容易获取）、模型的输入特征选择比较困难、如果系统发生变化则该模型需要重新训练。例如学术界比较著名的成果OtterTune便是采用了类似的方法。

强化学习（reinforcement learning，RL）在近些年发展迅速，基于深度学习的强化学习算法如DQN（deep q-networks，深度Q学习）、DDPG（deep deterministic policy gradient，深度确定性策略梯度算法）与PPO（proximal policy optimization，近端策略优化）等算法先后诞生，该类算法在游戏领域取得了比较好的效果，能够实现自动打游戏甚至游戏操作优于大多数的人类选手。与此同时，强化学习与监督学习不同，强化学习并不需要用户给定一个数据集，而是通过与环境进行交互，通过奖惩机制来学习哪些应该做，哪些不能做，从而给出更优的决策。

显然，强化学习能够应用到游戏领域，是因为游戏结果的好坏是比较明显的奖惩机制。输赢本身就是一个很好的价值导向，甚至能够不断获得经验值的游戏过程还能够得到连续不断的奖励，这就更容易让算法学到如何获取更多的经验。而反观数据库的调优过程，其实与游戏过程类似。数据库性能的好坏是比较明显的价值导向，数据库的参数配置就相当于游戏过程中的动作，数据库的状态信息也是可以获得的。因此，通过强化学习来进行数据库参数的调优是一个比较好的方案，该方法能够模仿DBA的调优过程，通过数据库性能的高低来激励好的参数配置。该方法的特点是能够从历史经验中进行学习，用训练后的模型进行参数推荐的过程也比较快，而且并不需要用户给定大量的训练数据。缺点是模型的训练过程比较复杂，算法中的奖励机制、数据库系统的状态等都需要精心设计，强化学习训练过程也比较慢。采用该类方法的代表性项目是由清华大学提出的QTune。

通过上述介绍，可以得出似乎并没有一种非常完美的方法能够覆盖到所有的应用场景。严格地讲，每类方法本身并没有优劣之分，只有更加适合业务场景的方法才能够称之为最优方法。因此，接下来将介绍一下openGauss开源的数据库参数调优工具X-Tuner，该工具综合了上述多种调优策略的优势。

总的来说，对数据库进行参数调优可以分为两大类，分别是离线参数调优和在线参数调优，X-Tuner同时支持上述两类调优模式。

（1） 离线参数调优是指在数据库脱离生产环境的基础上进行调优的，一般是在上线真实业务前进行压力测试，并通过压力测试的反馈结果进行参数调优。

（2） 在线参数调优是指不阻塞数据库的正常运行，在数据库运行中进行参数调优或推荐的过程。

具体来说，调优程序X-Tuner包含三种运行模式。

（1） recommend：获取当前正在运行的workload特征信息，根据上述特征信息生成参数推荐报告。报告当前数据库中不合理的参数配置和潜在风险等；输出当前正在运行的workload行为和特征；输出推荐的参数配置。该模式是秒级的，不涉及数据库的重启操作，其他模式可能需要反复重启数据库。

（2） train：通过用户提供的benchmark信息，迭代地进行参数修改和benchmark（一种用于测量硬件或软件性能的测试程序）执行过程，训练强化学习模型。通过反复的迭代过程，训练强化学习模型，以便用户在后面通过tune模式加载该模型进行调优。

（3） tune：使用优化算法进行数据库参数的调优，当前支持两大类算法，一种是深度强化学习，另一种是全局搜索算法（全局优化算法）。深度强化学习模式要求先运行train模式，生成训练后的调优模型，而使用全局搜索算法则不需要提前进行训练，可以直接进行搜索调优。如果在tune模式下，使用深度强化学习算法，要求必须有一个训练好的模型，且训练该模型时的参数与进行调优时的参数列表（包括max与min）必须一致。

无论是离线参数调优还是在线参数调优，X-Tuner都是支持的，他们的基本结构也是共用的。如图1所示，是X-Tuner各个模块的结构示意图以及交互形式。

如图1所示，X-Tuner可以大致分为DB侧、算法侧、主体逻辑模块以及benchmark，它的各个部分的功能说明如表1所示。

表1  X-Tuner的结构介绍

X-Tuner利用长期在openGauss上进行参数调优的先验规则，根据系统的workload、环境特征推荐初始参数调优范围，该范围便是待搜索的配置参数空间。利用算法（如强化学习、启发式算法等）在给定的参数空间上不断进行搜索，即可找到最优的参数配置。

常规评价调优效果好坏的方法是运行benchmark，包括TPC-C、TPC-H以及用户自定义的banchmark，用户只需要进行少量适配即可。离线参数调优的流程图如图2所示。

def main():
   …
# 通过命令行参数或连接信息文件构建db_info字典，利用该字典中的信息可以登录到数据库实例和宿主机上
    db_info = build_db_info(args)
    if not db_info:
        parser.print_usage()
        return -1


    # 解析配置文件中给定的配置项
    config = get_config(args.tuner_config_file)
    if not config:
        return -1


try:
    # 当获取到足够的信息后，进入工具的执行流程
        return procedure_main(mode, db_info, config)
    except Exception as e:
        logging.exception(e)
        print('FATAL: An exception occurs during program running. '
              'The exception information is "%s". '
              'For details about the error cause, please see %s.' % (e, config['logfile']),
              file=sys.stderr, flush=True)
        return -1
复制

可以看到main函数主要是做一些参数、命令行的校验、收集工作，核心流程定义在xtuner.py的procedure_main函数中，该函数的核心代码如下：

def procedure_main(mode, db_info, config):
    # 权限最小化
    os.umask(0o0077)
    # 初始化日志模块
    set_logger(config['logfile'])
logging.info('Starting... (mode: %s)', mode)
# 利用new_db_agent函数构造DB_Agent对象，该对象是唯一对数据库操作进行封装的对象
    db_agent = new_db_agent(db_info)


    # 如果用户没有通过配置文件指定负载类型，则通过预定义的算法或规则进行自动判断
    if config['scenario'] in WORKLOAD_TYPE.TYPES:
        db_agent.metric.set_scenario(config['scenario'])
    else:
        config['scenario'] = db_agent.metric.workload_type
    # 同上，如果用户设置为自动模式，则使用下述默认规则补充
    if config['tune_strategy'] == 'auto':
        # If more iterations are allowed, reinforcement learning is preferred.
        if config['rl_steps'] * config['max_episode_steps'] > 1500:
            config['tune_strategy'] = 'rl'
        else:
            config['tune_strategy'] = 'gop'


logging.info("Configurations: %s.", config)
# 如果在配置文件中指定了tuning_list配置项，并且非reocmmend模式，则加载该待调优参数列表的配置文件，否则通过recommend_knobs函数智能获取待调优参数列表
    if config['tuning_list'].strip() != '' and mode != 'recommend':
        knobs = load_knobs_from_json_file(config['tuning_list'])
    else:
        print("Start to recommend knobs. Just a moment, please.")
        knobs = recommend_knobs(mode, db_agent.metric)
    if not knobs:
        logging.fatal('No recommended best_knobs for the database. Stop the execution.')
        return -1


    # 如果是调优和训练模式，由于某些数据库参数是需要重启后才生效的，因此可能会伴随着反复的重启过程
    if mode != 'recommend':  # 不为recommend模式，就只能是tune或者train模式，而这两种模式都是离线过程，需要反复迭代
        prompt_restart_risks()  # 告知用户调优过程中有数据库重启的风险
        # 初始化调优中的记录类
        recorder = Recorder(config['recorder_file'])
        # 分别读取配置文件中的三个配置项：benchmark_script、benchmark_path以及benchmark_cmd，通过这三个配置项就可以获取到benchmark驱动脚本的实例，可以用它来衡量数据库的性能
        bm = benchmark.get_benchmark_instance(config['benchmark_script'],
                                              config['benchmark_path'],
                                              config['benchmark_cmd'],
                                              db_info)
        # 初始化数据库调优环境实例，该对象封装了迭代过程，保持与强化学习库gym.Env的接口一致
        env = DB_Env(db_agent, benchmark=bm, recorder=recorder,
                     drop_cache=config['drop_cache'],
                     mem_penalty=config['used_mem_penalty_term'])
        env.set_tuning_knobs(knobs)
        # 识别不同的模式，不同模式执行对应的子程序
        if mode == 'train':
            rl_model('train', env, config)
        elif mode == 'tune':
            …
    # 执行到此处时，已经完成调优过程。下述代码负责将调优结果输出
    knobs.output_formatted_knobs()
    if config['output_tuning_result'] != '':
        with open(config['output_tuning_result'], 'w+') as fp:
            # train模式是强化学习独有的模式，在该模式下，只输出调优参数，不输出报告参数（建议参数）。这是因为，在强化学习的tune模式下，待调优参数列表应当与train模式下保存的调优列表需要完全相同，即调优参数名相同、调优范围相同、各个参数的顺序相同，否则会导致输入特征不符合。
            knobs.dump(fp, dump_report_knobs=mode != 'train')
    logging.info('X-Tuner is executed and ready to exit. '
                 'Please refer to the log for details of the execution process.')
    return 0
复制

# 提示：你需要先把数据导入到数据库中
# 调优程序会自动调用下述函数，该函数返回结果值就是benchmark测试结果
# path 变量表示实际benchmark所在路径
path = ''
# cmd变量定义了使用什么shell命令才可以启动benchmark
cmd = ''


# 函数定义了远端和本地的命令行接口，通过exec_command_sync()方法执行shell命令
def run(remote_server, local_host) -> float:
    return 0
复制

from tuner.exceptions import ExecutionError


# 提示：你需要自己下载benchmark-sql测试工具，同时使用openGauss的JDBC驱动替换PostgreSQL目录下的JDBC驱动文件。你需要自己配置好TPC-C测试配置


# 测试程序通过下述命令运行
path = '/path/to/benchmarksql/run'  # TPC-C测试脚本benchmark-sql的存放路径
cmd = "./runBenchmark.sh props.gs"  # 自定义一个名为props.gs的benchmark-sql测试配置文件
    
    
def run(remote_server,local_host):
    # 切换到TPC-C脚本目录下，清除历史错误日志，然后运行测试命令
    # 此处最好等待几秒钟，因为benchmark-sql测试脚本生成最终测试报告是通过一个shell脚本实现的，整个过程会有延迟
    # 为了保证能够获取到最终的tpmC数值报告，这里选择等待3秒钟
    stdout, stderr = remote_server.exec_command_sync(['cd %s' % path, 'rm -rf benchmarksql-error.log', cmd, 'sleep 3'])
    # 如果标准错误流中有数据，则报异常退出
    if len(stderr) > 0:
        raise ExecutionError(stderr)
    
    # 寻找最终tpmC结果
    tpmC = None
    split_string = stdout.split()  # 对标准输出流结果进行分词
    for i, st in enumerate(split_string):
        # 在benchmark-sql 5.0中，tpmC最终测试结果数值在‘(NewOrders)’关键字的后两位，正常情况下，找到该字段后直接返回即可
        if "(NewOrders)" in st:
            tpmC = split_string[i + 2]
            break
    stdout, stderr = remote_server.exec_command_sync(
        "cat %s/benchmarksql-error.log" % path)
    nb_err = stdout.count("ERROR:")  # 判断整个benchmark运行过程中，是否有报错，记录报错的错误数
    return float(tpmC) - 10 * nb_err  # 这里将报错的错误数作为一个惩罚项，惩罚系数为10，越高的惩罚系数表示越看中报错的数量
复制

db=opengauss
driver=org.postgresql.Driver
// 配置连接信息
conn=jdbc:postgresql://192.168.1.100:5678/tpcc
…


// 定义数据量
warehouses=1
loadWorkers=4


// 定义并发量
terminals=100
//To run specified transactions per terminal- runMins must equal zero
runTxnsPerTerminal=10
//To run for specified minutes- runTxnsPerTerminal must equal zero
runMins=0
//Number of total transactions per minute
limitTxnsPerMin=300
  …
复制

import time
    
from tuner.exceptions import ExecutionError
    
# 提示：你需要先自行导入数据，然后准备sql测试文件
# 下述程序会自动采集整体运行时延
path = '/path/to/tpch/queries'  # 存放TPC-H测试用的SQL脚本目录
cmd = "gsql -U {user} -W {password} -d {db} -p {port} -f {file}"  # 需要运行TPC-H测试脚本的命令，一般使用'gsql -f 脚本文件'来运行
# 需要指出的是，由于可能会通过gsql连接数据库，因此可能会需要用户名、密码等信息，可以通过上述占位符，如{user}、{password}等进行占位，X-Tuner会自行渲染
    
def run(remote_server, local_host):
    …
    # 代价为全部测试用例的执行总时长
    cost = time.time() - time_start
    # 取相反数，适配run 函数的定义：返回结果越大表示性能越好。
    return - cost
复制

def get_benchmark_instance(script, path, cmd, db_info):
    …
# 验证benchmark 脚本有效性，如果没有指定path与cmd变量，会抛出异常
    if (not getattr(bm, 'path', False)) or (not getattr(bm, 'cmd', False)) or (not getattr(bm, 'run', False)):
        raise ConfigureError('The benchmark script %s is invalid. '
                             'For details, see the example template and description document.' % script)
    # 检查run函数是否存在，且参数数量为2，即本地和远程两个shell接口
    check_run_assertion = isinstance(bm.run, types.FunctionType) and bm.run.__code__.co_argcount == 2
    if not check_run_assertion:
        raise ConfigureError('The run function in the benchmark instance is not correctly defined. '
                             'Redefine the function by referring to the examples.')


# cmd与path变量，优先使用配置文件中的配置项，如果没有对应的配置项，则默认使用脚本中的内容
    if path.strip() != '':
        bm.path = path
    if cmd.strip() != '':
        bm.cmd = cmd


    # 渲染cmd命令中的占位符
    bm.cmd = bm.cmd.replace('{host}', db_info['host']) \
        .replace('{port}', str(db_info['port'])) \
        .replace('{user}', db_info['db_user']) \
        .replace('{password}', db_info['db_user_pwd']) \
        .replace('{db}', db_info['db_name'])


    # 将数据库宿主机的shell接口包装起来
    def wrapper(server_ssh):
        return bm.run(server_ssh, local_ssh)


    return wrapper
复制

class Knob(object):
    def __init__(self, name, knob):
        …


    # 将整形数值转换为数据库可以接受的字符串型字面量
    def to_string(self, val):
        …


    #  将字符串型的字面量转换为数值型
    def to_numeric(self, val):
        …
复制

class DB_Agent:
    def __init__(self, host, host_user, host_user_pwd,
                 db_user, db_user_pwd, db_name, db_port, ssh_port=22):
        …


        # 设置语句的执行时间不限
        self.set_knob_value("statement_timeout", 0)


        # 初始化数据库的特征指标接口
        self.metric = openGaussMetric(self)


    def check_connection_params(self):
        # 检查数据库连接参数是否正确
        …


    def set_tuning_knobs(self, knobs):
        # 设置调优参数，参数类型为RecommendedKnobs, 该类在knob.py文件中定义
        if not isinstance(knobs, RecommendedKnobs):
            raise TypeError


        self.knobs = knobs
        self.ordered_knob_list = self.knobs.names()
        … 
def exec_statement(self, sql, timeout=None):
        # 在数据库内执行SQL语句，是通过调用gsql命令来实现的
        command = "gsql -p {db_port} -U {db_user} -d {db_name} -W {db_user_pwd} -c \"{sql}\";".format(
            db_port=self.db_port,
            db_user=self.db_user,
            db_name=self.db_name,
            db_user_pwd=self.db_user_pwd,
            sql=sql
        ) 
        …


    def is_alive(self):
        # 检查数据库是否运行
        ...


    def exec_command_on_host(self, cmd, timeout=None, ignore_status_code=False):
        # 在数据库的宿主机上执行shell命令
        ...


    def get_knob_normalized_vector(self):
        # 获取待调优参数的结果，并将其进行归一化（映射到0与1之间）。返回结果是一个列表
        nv = list()
        for name in self.ordered_knob_list:
            val = self.get_knob_value(name)
            nv.append(self.knobs[name].to_numeric(val))
        return nv


    def set_knob_normalized_vector(self, nv):
        # 与get_knob_normalized_vector()方法对应，参数nv表示normalized_vector，即都是已经映射到0与1之间的、经过数值化的参数值，将这些参数值设置到数据库上
        restart = False
        for i, val in enumerate(nv):
            name = self.ordered_knob_list[i]
            knob = self.knobs[name]
            self.set_knob_value(name, knob.to_string(val))
            restart = True if knob.restart else restart


        # 如果这些待设置的参数中有需要重启数据库的，则重启数据库以便使设置后的参数生效
        if restart:
            self.restart()


    def get_knob_value(self, name):
        # 单独获取某个参数的值，该参数值是不经标准化的
        check_special_character(name)
        sql = "SELECT setting FROM pg_settings WHERE name = '{}';".format(name)
        _, value = self.exec_statement(sql)
        return value


    def set_knob_value(self, name, value):
        # 单独设置某个参数的值，该参数值是不经标准化的，通过gs_guc命令设置数据库参数值
        logging.info("change knob: [%s=%s]", name, value)
        try:
            self.exec_command_on_host("gs_guc reload -c \"%s=%s\" -D %s" % (name, value, self.data_path))
        except ExecutionError as e:
            if str(e).find('Success to perform gs_guc!') < 0:
                logging.warning(e)


    def reset_state(self):
        # 重置数据库的状态，例如对 pg_stat_database等系统表进行重置
        self.metric.reset()


    def set_default_knob(self):
        # 设置数据库的参数值为默认值，该默认值通过knob类型指定，即在对应的配置文件中指定的值
        restart = False


        for knob in self.knobs:
            self.set_knob_value(knob.name, knob.default)
            restart = True if knob.restart else restart


        self.restart()


    def restart(self):
        # 重启数据库
        ...


    def drop_cache(self):
        # 对于openGauss数据库来说，drop cache可以使每次benchmark的跑分更加稳定，但是这需要root权限
        # 如果用户需要drop cache，则可以向/etc/sudoers中写入'username ALL=(ALL) NOPASSWD: ALL'
复制

def rl_model(mode, env, config):
    # 由于加载tensorflow的过程过于耗时，且并非是必要的，因此采用懒加载的模式
from tuner.algorithms.rl_agent import RLAgent


# 启动强化学习代理类
rl = RLAgent(env, alg=config['rl_algorithm'])


# 训练和调优两种模式对应不同的执行流程
# 模型需要先训练，然后才可以利用该模型进行调优。训练和调优过程的输出是待调优参数列表，由于共用一套模型，因此两种模式下，要求待调优的参数列表必须是一致的，否则会抛出输出维度不同的异常。
    if mode == 'train':
        logging.warning('The list of tuned knobs in the training mode '
                        'based on the reinforcement learning algorithm must be the same as '
                        'that in the tuning mode. ')
# 比较关键的参数是最大迭代轮次rl_steps，理论上越长越精准，但是也更加耗时
# max_episode_steps是强化学习算法中的每一轮的最大回合次数，在X-Tuner实现中，该参数被弱化了，一般默认即可
        rl.fit(config['rl_steps'], nb_max_episode_steps=config['max_episode_steps'])
        rl.save(config['rl_model_path'])
        logging.info('Saved reinforcement learning model at %s.', config['rl_model_path'])
    elif mode == 'tune':
        …
复制

def global_search(env, config):
method = config['gop_algorithm']


# 判断选择使用哪种算法
    if method == 'bayes':
        from bayes_opt import BayesianOptimization


        action = [0 for _ in range(env.nb_actions)]
        pbound = {name: (0, 1) for name in env.db.ordered_knob_list}


        # 定义一个黑盒函数，用于适配第三方库的接口
        def performance_function(**params):
            assert len(params) == env.nb_actions, 'Failed to check the input feature dimension.'


            for name, val in params.items():
                index = env.db.ordered_knob_list.index(name)
                action[index] = val


            s, r, d, _ = env.step(action)
            return r  # 期望结果越大越好


        optimizer = BayesianOptimization(
            f=performance_function,
            pbounds=pbound
        )
        optimizer.maximize(
            # 最大迭代轮次越大结果越精准，但是也更耗时
            n_iter=config['max_iterations']
        )
    elif method == 'pso':
        from tuner.algorithms.pso import Pso


        def performance_function(v):
            s, r, d, _ = env.step(v, False)
            return -r  # 因为PSO算法的实现中是寻找全局最小值，这里取相反数，就改为取全局最大值


        pso = Pso(
            func=performance_function,
            dim=env.nb_actions,
            particle_nums=config['particle_nums'],
# 最大迭代轮次越大结果越精准，但是也更耗时
            max_iteration=config['max_iterations'],
            x_min=0, x_max=1, max_vel=0.5
        )
        pso.minimize()
    else:
        raise ValueError('Incorrect method value: %s.' % method)
复制

 @cached_property
    def shared_buffers(self):
        # 此处应用的是DBA普遍认同的调优策略：在大内存环境下，shared_buffer占比可更高一些，小内存情况下占比应下调
        mem_total = self.metric.os_mem_total  # unit: kB
        if mem_total < 1 * SIZE_UNIT_MAP['GB']:
            default = 0.15 * mem_total
        elif mem_total > 8 * SIZE_UNIT_MAP['GB']:
            default = 0.4 * mem_total
        else:
            default = 0.25 * mem_total


        recommend = default  self.metric.block_size
        if self.metric.is_64bit:
            database_blocks = self.metric.all_database_size  self.metric.block_size
            # 如果数据库文件的比较小，则shared_buffer 也无须设置得太大，否则便是浪费资源
            if database_blocks < recommend:
                self.report.print_warn("The total size of all databases is less than the memory size. "
                                       "Therefore, it is unnecessary to set shared_buffers to a large value.")


            recommend = min(database_blocks, recommend)
            upper = recommend * 1.15
            lower = min(0.15 * mem_total  self.metric.block_size, recommend)


            return Knob.new_instance(name="shared_buffers",
                                     value_default=recommend,
                                     knob_type=Knob.TYPE.INT,
                                     value_max=upper,
                                     value_min=lower,
                                     restart=True)
        else:
            # 对于非64位操作系统，shared_buffer无须设置得太大
            upper = min(recommend, 2 * SIZE_UNIT_MAP["GB"] / self.metric.block_size)  # 32-bit OS only can use 2 GB mem.
            lower = min(0.15 * mem_total / self.metric.block_size, recommend)
            return Knob.new_instance(name="shared_buffers",
                                     value_default=recommend,
                                     knob_type=Knob.TYPE.INT,
                                     value_max=upper,
                                     value_min=lower,
                                     restart=True)
复制

方法一：直接通过源代码运行。

pip install -r requirements.txt
复制

（2） 安装成功后需要添加环境变量PYTHONPATH，然后执行main.py主文件，方法如下：

cd tuner # 切换到main.py文件所在的目录中
export PYTHONPATH='..'  # 将上一级目录添加到PYTHONPATH环境变量中，即可寻找到包所在的路径
python main.py --help  # 执行相应的功能，此处以获取帮助为例
复制

python setup.py install
复制

gs_xtuner --help
复制

gs_xtuner recommend --db-name opengauss --db-user omm --port 5678 --host 192.168.1.100 --host-user omm
复制

当然，上面的数据库连接信息比较长，也可以通过json文件的格式传入，某个包含数据库连接信息的json格式文件内容如下：

{
  "db_name": "opengauss",  # 数据库名
  "db_user": "omm",       # 登录到数据库上的用户名
  "host": "127.0.0.1",    # 数据库宿主机的IP地址
  "host_user": "omm",     # 登录到数据库宿主机的用户名
  "port": 5432,           # 数据库的侦听端口号
  "ssh_port": 22          # 数据库宿主机的SSH侦听端口号
}
复制

假设上述文件名为connection.json，则通过下述命令即可使用该文件。

gs_xtuner recommend –f connection.json
复制

select name, setting from pg_settings;
复制

训练模式和调优模式的过程类似，区别仅在于对配置文件的配置。X-Tuner模式使用的配置文件路径可以通过–help命令获取，代码如下所示：

...  
 -x TUNER_CONFIG_FILE, --tuner-config-file TUNER_CONFIG_FILE
                        This is the path of the core configuration file of the
                        X-Tuner. You can specify the path of the new
                        configuration file. The default path is /path/to/xtuner/xtuner.conf.
                        You can modify the configuration file to control the
                        tuning process.
...
复制

（1） rl_algorithm：用于训练强化学习模型的算法，当前支持设置为ddpg。

（2） rl_model_path：训练后生成的强化学习模型保存路径。

（3） rl_steps：训练过程的最大迭代步数。

（4） max_episode_steps：每个回合的最大步数。

（5） scenario：明确指定的workload类型，如果为auto则为自动判断。在不同模式下，推荐的调优参数列表也不一样。

（6） tuning_list：用户指定需要调哪些参数，如果不指定，则根据workload类型自动推荐应该调的参数列表。如需指定，则tuning_list表示调优列表文件的路径。调优列表配置文件的文件内容示例如下所示：

{
  "work_mem": {
    "default": 65536,
    "min": 65536,
    "max": 655360,
    "type": "int",
    "restart": false
  },
  "shared_buffers": {
    "default": 32000,
    "min": 16000,
    "max": 64000,
    "type": "int",
    "restart": true
  },
  "random_page_cost": {
    "default": 4.0,
    "min": 1.0,
    "max": 4.0,
    "type": "float",
    "restart": false
  },
  "enable_nestloop": {
    "default": true,
    "type": "bool",
    "restart": false
  }
}
复制

待上述配置项配置完成后，可以通过下述命令启动训练：

gs_xtuner train -f connection.json
复制

（1） tune_strategy：指定选择哪种算法进行调优，支持RL、GOP以及auto（自动选择）。若该参数设置为RL，则RL相关的配置项生效。除train模式下生效的配置项外，test_episode配置项也生效，该配置项表明调优过程的最大回合数，该参数直接影响了调优过程的执行时间（一般地，数值越大越耗时）。

（2） gop_algorithm：选择何种全局搜索算法，支持bayes以及PSO。

（3） max_iterations：最大迭代轮次，数值越高搜索时间越长，效果往往越好。

（4） particle_nums：在PSO算法上生效，表示粒子数。

（5） 待上述配置项配置完成后，可以通过下述命令启动调优。

gs_xtuner tune -f connection.json
复制