# Automatic Configuration Tuning on Cloud Database: A Survey

Limeng Zhang and M. Ali Babar Limeng Zhang and M. Ali Babar are with the
Centre for Research on Engineering Software Technologies (CREST), The
University of Adelaide, Australia.
E-mail<EMAIL_ADDRESS>
<EMAIL_ADDRESS>
###### Abstract

Faced with the challenges of big data, modern cloud database management
systems are designed to efficiently store, organize, and retrieve data,
supporting optimal performance, scalability, and reliability for complex data
processing and analysis. However, achieving good performance in modern
databases is non-trivial as they are notorious for having dozens of
configurable knobs, such as hardware setup, software setup, database physical
and logical design, etc., that control runtime behaviors and impact database
performance. To find the optimal configuration for achieving optimal
performance, extensive research has been conducted on automatic parameter
tuning in DBMS. This paper provides a comprehensive survey of predominant
configuration tuning techniques, including Bayesian optimization-based
solutions, Neural network-based solutions, Reinforcement learning-based
solutions, and Search-based solutions. Moreover, it investigates the
fundamental aspects of parameter tuning pipeline, including tuning objective,
workload characterization, feature pruning, knowledge from experience,
configuration recommendation, and experimental settings. We highlight
technique comparisons in each component, corresponding solutions, and
introduce the experimental setting for performance evaluation. Finally, we
conclude this paper and present future research opportunities. This paper aims
to assist future researchers and practitioners in gaining a better
understanding of automatic parameter tuning in cloud databases by providing
state-of-the-art existing solutions, research directions, and evaluation
benchmarks.

###### Index Terms:

Cloud database, Knob tuning, Configuration tuning, automatic tuning.

##  1 Introduction

In the increasingly digitized age, vast and diverse volumes of data are
generated from various sources, including mobile devices, social media
platforms, sensors, and more. Faced with this data explosion, cloud database
management systems (DBMS) cloud database management systems (DBMS) for data
storage, coupled with big data analytics frameworks (BDAF), have emerged as
powerful solutions to tackle the complexities of handling and processing
massive and intricate data sets in a scalable and flexible manner. This makes
them invaluable tools for organizations grappling with the challenges of big
data and digital transformation [1, 2].

However, achieving good performance in modern DBMSs is non-trivial. Modern
DBMSs have hundreds of configurable knobs regarding hardware setup, software
configuration, database physical and logical design, that affect their
performance [3, 4, 5, 6]. Efficient parameter configurations can strike a
balance between resource utilization, query responsiveness, and cost-
effectiveness, while an inappropriate configuration can lead to significant
performance degradation and inefficient usage of system resources [7, 8, 9,
10, 11, 12, 6, 3, 13].

###  1.1 Configuration Parameter Tuning Challenges

In order to find an optimal configuration for a DBMS workload, either a
database administrator or a tuning program has to address a number of
challenges. First, the parameter space is vast and intricate, with a large
number of knobs existing in continuous space, and the number of DBMS knobs
continues to grow with each new version and feature release. Staying abreast
of these changes and comprehending their implications for system performance
presents an ongoing challenge for database administrators [8, 3]. Second, the
interdependence of parameters within DBMSs complicates the optimization
process. Altering one knob may have repercussions on the effectiveness of
another, introducing nonlinear correlations that pose difficulties for both
manual and model-based configuration identification. Third, the diversity and
heterogeneity of workloads, hardware, and other environmental factors in a
DBMS further contribute to the complexity. A DBMS may host numerous instances,
each accommodating various types of workloads. Real-world application
workloads are dynamic, with properties such as workload types, workload
parallelization, workload records, and operations counts exhibiting variations
over time [3, 9]. Furthermore, training samples are scarce due to the time-
intensive process of gathering historical observations and the complexity
introduced by high-dimensional parameters. Addressing these challenges
requires sophisticated approaches and tools to enhance the efficiency of DBMSs
in diverse and dynamic operational environments.

###  1.2 Contributions

Through an investigation into the state-of-the-art automatic DBMS
configuration tuning, we aim to provide researchers, developers, and
practitioners with comprehensive insights and guidance in the field. In this
study, our contributions are fourfold:

  1. 1.

We provide an overview of a wide spectrum of prominent automatic tuning
methods for cloud databases, as discussed in various studies [10, 8, 14, 11,
9, 12, 15, 6, 3, 13, 16, 17, 18]. These methods include Bayesian optimization-
based methods, Neural network-based methods, Reinforcement learning-based
methods, and Search-based methods. Meanwhile, we also include several relevant
automatic tuning methods [19, 20, 7, 21], which focus on big data analytics
framework but encounter similar challenges in identifying the optimal
configuration within the complex and dependent configuration space.

  2. 2.

We outline the primary tuning objectives and summarize three main constraints
or factors frequently discussed in automatic configuration tuning in DBMS
(Section 2): overhead, adaptivity, and safety.

  3. 3.

We provide a comprehensive overview of the automatic tuning pipeline,
encompassing Workload Characterization (Section 4), Feature Pruning (Section
5), Knowledge from Experience (Section 6), Configuration Recommendation
(Section 7). We describe in detail the key features in each part.

  4. 4.

We providing a comprehensive summary of popular open-source benchmarks
utilized for evaluating database performance optimization.

TABLE I: Summary of tuning objective

Category | Work | Target | Objective | Constraints/Factors
---|---|---|---|---
DBMS | BDAF | Performance | Others | Overhead | Adaptivity | Safety
BO |  Ottertune [8] | ✓ | - |  latency |  - |  - |  - |  -
RelM [19] |  | ✓ |  execution time |  memory efficiency |  memory allocation efficiency |  - |  out of memory
RestTune [6] | ✓ | - |  |  resource utilization |  CPU, I/O and memory |  - |  -
CGPTuner [17] | ✓ | - |  throughput, response time, etc. |  - |  - |  JVM and OS |  -
LlamaTune [16] | ✓ | - |  throughput, latency |  - |  - |  - |  -
ONLINETUNE [3] | ✓ | - |  throughput, latency, etc. |  - |  - |  underlying data |  performance degradation
LOCAT [7] | - | ✓ |  execution time |  - |  - |  data size |  -
RF |  CDBTune [12] | ✓ | - |  throughput and latency |  - |  - |  - |  -
Qtune [9] | ✓ | - |  throughput and latency |  - |  - |  - |  -
MMOT [22] | ✓ | - |  throughput and latency |  - |  - |  - |  -
WATuning [23] | ✓ | - |  throughput and latency |  - |  - |  read/write ratio |  -
|  HUNTER [13] | ✓ | - |  throughput and latency |  - |  - |  - |  -
|  DB-BERT [18] | ✓ | - |  throughput or execution time |  - |  - |  - |  -
NN |  LITE [21] | - | ✓ |  latency |  - |  - |  application diversity and cluster environment |  -
|  iBTune [15] | ✓ | - |  - |  buffer size |  - |  - |  -
Search |  BestConfig [10] | ✓ | ✓ |  user-defined performance |  - |  - |  - |  -
AutoTune [11] | - | ✓ |  execution time |  - |  CPU, memory, disk and network |  - |  -
UDAO [20] | - | ✓ |  execution time |  - |  user-concerned aspects |  - |  -

##  2 Tuning Objectives

In the context of DBMS configration uning, the primary objective is to
maximize the Performance, such as throughput and latency (e.g., 95th
percentile latency). This aims to gauge the DBMS’s ability to efficiently
handle a higher volume of workloads or queries.

Additionally, several other aspects/objectives can also be considered during
the tuning process as summarised in Table I, including:

  * •

Overhead: Focuses on the amount of time or system resources the method
requires to recommend knob settings, including tuning time, Total Cost of
Ownership (TCO), and resource utilization (such as CPU utilization), etc. For
example, RelM [19] concentrates on optimizing memory allocation for such
applications. RestTune [6] aims to reduce resource utilization while still
guaranteeing the Service Level Agreement (SLA), e.g., without violating
throughput and latency requirements.

  * •

Adaptivity: Evaluates how well the method performs in new and varying
scenarios, such as hardware adaptation for changes in I/O, memory, workload
adaptation for varying request rates and data sizes, etc.

  * •

Safety: One crucial facet of safety lies in the ability of a tuning method to
avoid recommending parameter configurations that could potentially degrade
system performance. ONLINETUNE [3], which focuses on tuning online databases
safely in changing cloud environments, addresses this concern. The safety
threshold, as defined in ONLINETUNE, is anchored to the baseline performance
exhibited under the default configuration, denoted as default performance.
Beyond performance-centric safety assessments, resource allocation represents
another pivotal dimension. Within this context, Kunjir et al. [19] present
RelM, wherein safety concerns are framed in terms of resource utilization
aligning with allocated thresholds

##  3 Overview of Tuning Framework

In this study, we break down the entire knob tuning pipeline into five
essential components: Workload Characterization, Feature Pruning, Knowledge
from Experience, Configuration Recommendation as depicted in Fig. 1. The
initial phase, Workload Characterization, is crafted to comprehensively model
a workload, utilizing either logical-level queries or embedding runtime
metrics for a dynamic understanding of performance indicators Feature Pruning,
applied both at the workload-level to minimize execution time and at the
configuration-level to streamline the search space, is strategically employed
to enhance efficiency through the application of pruning techniques. Knowledge
from Experience draws upon historical insights, enabling the tuning algorithm
to efficiently converge towards optimal configurations. Finally, Configuration
Recommendation involves utilizing diverse techniques, including Bayesian
Optimization, Neural networks, Reinforcement learning, and Search-based
methods, to generate configurations finely tailored to the specific
characteristics of the workload.

Figure 1: The general framework of automatic configuration tuning on DBMS.

##  4 Workload Characterization

The initial step in the tuning system involves modeling the characteristics of
the target workload to facilitate the tuning algorithm in acquiring knowledge
from historical data, thereby accelerating the tuning process or improving
coverage to achieve optimal configurations. In this section, we present two
main aspects for modeling DBMS workloads: a query-level characterization based
on the queries composed in a workload and a runtime-based characterization
based on DBMS runtime statistics obtained during the execution of the
instance.

###  4.1 Query-level Characterization

Query-level characterization aims at modeling a workload from its composed
queries [3]. A DBMS application allows users and other applications to engage
with the database by formulating and executing queries, such as SELECT,
INSERT, UPDATE, DELETE—tailored to manipulate and retrieve information and
accomplish various tasks. Hence, researchers have endeavored to model a
workload by analyzing the composition of queries and utilizing query
characteristics to represent the workload [3]. Existing work on query-level
characterization can be summarized as follows:

  * •

Features from the query text: In a DBMS workload, each query will perform a
certain type of operation within the DBMS. Hence, some researchers try to
characterize a workload by analyzing its static query text and then merging
each query vector to ultimately represent the workload. RestTune [6] analyzes
the cost of a MySQL workload by examining the distribution of queries within
each workload based on their reserved SQL keywords (e.g., SELECT, UPDATE,
DISTINCT). Initially, it identifies the reserved operation keywords for each
query and subsequently computes their TF-IDF (term frequency-inverse document
frequency) values. These TF-IDF feature vectors serve as input for a random
forest model utilized for classification. This model provides a predicted
probability distribution regarding predefined resource cost levels for each
query. Ultimately, the average of the probability distributions for all
queries across the entire workload is calculated to represent the meta-feature
cost for the input workload. LOCAT [7] features a Spark SQL workload directly
with its query composition. It then filters out some unimportant queries and
uses those important queries to represent a workload when evaluating the
performance of recommended configuration. ONLINETUNE [3] features a workload
in terms of the query arrival rate within it and its query composition. It
leverages a standard LSTM encoder-decoder network to encode each query in the
workload. Subsequently, it averages the query encodings to obtain the
composition feature of the workload.

  * •

Features from the query plan: In addition to the static query text, some
researchers model a query through looking into its execution process. When a
query is submitted to the DBMS, the system first parses the query to check its
syntax and semantics. After parsing, the query is compiled into an execution
plan, which outlines the steps needed to execute the query efficiently. Some
researchers represent a query through parsing its query plan to aggregate key
features, including the cost or categories of operators, scanned tables, and
predicates, and then featurizing the workload with the query vectors. In Qtune
[9], each SQL query is represented with features including query type (e.g.,
insert, delete, select, update), involved tables, and the estimated processing
cost derived from inherent operations (e.g., scan, hash join, aggregate).
Then, it merges all the query vectors into a unified workload vector according
to its predefined merging strategies for each part.

  * •

Features from other query-related factors. In addition to the aforementioned
query features, certain studies consider the underlying data distribution in
the database as an informative factor, based on the observation that only data
changes affecting the workload queries are relevant to the tuning policy.
Building upon this premise, ONLINETUNE [3] extracts the database data
distribution by leveraging insights from the DBMS optimizer, which encompass
estimates of rows scrutinized by queries, the proportion of rows filtered by
table conditions in queries, and the utilization of indexes. Subsequently, it
computes the average of these three query features to derive the underlying
data distribution associated with a workload. Finally, combined with the
features extracted from query text, it concatenates the workload feature and
underlying data feature to obtain the final contextual features.

###  4.2 Runtime-based Characterization

In addition to characterizing a workload in terms of queries, a workload can
also be characterized by its runtime characteristics. Modern DBMSs provide
extensive information about workload running behavior [8]. For example,
MySQL’s InnoDB engine [24] provides statistics on the number of pages
read/written, query cache utilization, and locking overhead. OtterTune [8]
characterizes a workload using such numeric metrics, such as the number of
pages read/written, query cache utilization, and locking overhead, etc, to
reflect various aspects of its runtime behavior. Additionally, researchers can
also define new performance indicators tailored to unique requirements. For
instance, RelM [19] profiles the memory allocation of a BDAF application with
different configuration parameters, along with customized performance metrics
regarding memory management decisions at multiple levels, including the
resource-management level, container level, application level, and inside the
Java Virtual Machine.

Apart from workload-related and runtime-related features, other factors
associated with workload execution can also be considered, such as features
related to running experiments and data. LITE [21] provides insights on
incorporating code semantics features and scheduler features alongside model
input data features (such as column number, rows, iteration number, and
partition number), as well as cluster environment factors related to nodes,
memory, CPU frequency, and bandwidth when generating configurations for
applications in Spark.

##  5 Feature Pruning

Given the diversity of workloads and the high-dimensional configurable
parameters of DBMSs, both data collection and configuration space search can
be time-intensive. Hence, employing strategies to mitigate workload execution
time and streamline the search space becomes imperative. In this section, we
present pruning strategies at two levels: workload-level pruning to optimize
workload execution time and configuration-level pruning for enhancing search
space efficiency.

Table II provides a technical comparison of strategies on feature pruning (in
Section 5) and knowledge extraction (in Section 6) from existing tuning
methods.

TABLE II:  Strategies of Feature Pruning and Knowledge From Experience Work | Feature Pruning | Knowledge From Experience
---|---|---
Workload-level | Configuration-level | Strategy | Aims
LOCAT [7] | CV | SRCC, KPCA |  - |
Ottertune [8] | FA, k-means | LASSO |  Euclidean distance |  Training data construction
ResTune [6] | - | - |  Epanechnikov quadratic kernel (static), Performance surface (dynamic) |  Model ensembling weight
LlamaTune [16] | - | HeSBO |  - |  -
HUNTER [13] | PCA | RF |  - |  -
CGPTuner [17] | - | - |  - |  Data normalization, Model training
MMOT [22] | 3-layer autoencoder | - |  Cosine similarity |  Model selection

###  5.1 Workload-level Pruning

Workload-level pruning strategies primarily contribute to two aspects: data
collection and model training. Query-level filtering aims to remove
unimportant queries from a workload, thereby reducing the execution time of
each workload and accelerating both training data collection and model
validation. Workload Feature Selection aims to reduce the dimensionality of
each workload feature, thereby decreasing the training time for autotuning
models.

####  5.1.1 Query-level Filtering

Considering that each application consists of a number of queries, the
execution time of a workload can be decreased through removing some
unimportant queries. Query filtering aims to removing the unimportant queries
which are not sensitive to the configuration parameters.

  * •

Coefficient of Variation (CV): is a statistical measure that provides insights
into the relative variability of a set of values. It is calculated as the
ratio of the standard deviation to the mean, expressed as a percentage. LOCAT
[7] utilizes CV to identify and eliminate configuration-insensitive queries
whose performance (query execution time) is not affected by configuration
changes within an application. It first constructs a matrix of the execution
time for each query under different Spark SQL configurations (30 configuration
instances) and then calculates the CV to filter queries with smaller CV
values, categorizing them as ’configuration-insensitive’.

####  5.1.2 Workload Feature Selection

Workload feature selection aims to reduce the dimensionality of workload
features. Existing strategies applied in the automatic parameter tuning on
DBMSs include:

  * •

k-means: is a popular unsupervised machine learning algorithm used for
partitioning a dataset into clusters based on similarity. The primary goal of
k-means is to group data points in such a way that points within the same
cluster are more similar to each other than to points in other clusters. In
Ottertune [8], each workload is represented with runtime metrics. When
conducting workload feature selection, factor analysis (FA) is first applied
to transform the (potentially) high-dimensional DBMS metric data into lower-
dimensional features. Then k-means, to cluster this lower dimensional data
into meaningful clusters (for reducing noise data) and select a single metric
for each cluster, namely, the one closest to the cluster center. During the
process, number of clusters is determined through a heuristic model proposed
in the work [25].

  * •

Factor analysis (FA): is a statistical technique used for identifying
underlying latent factors that explain the observed relationships among a set
of variables. The key assumption in factor analysis is that observed variables
are linear combinations of unobservable latent factors and random error terms.
Ottertune [8] utilizes it to transform the (potentially) high-dimensional DBMS
metric embedding vector into lower-dimensional features.

  * •

Principal Component Analysis (PCA): is a popular linear dimension reduction
method that transforms correlated variables into uncorrelated ones, known as
principal components. It does so by calculating the covariance matrix,
performing eigendecomposition, and selecting a subset of principal components
based on their variance. HUNTER [13] applies PCA to complete the feature
reduction on its collected workload runtime metrics for a workload, which
including number of lush statements executed, number of threads activated,
etc.

  * •

Autoencoder: is a neural network architecture meticulously devised to achieve
precise reconstruction of its input. Comprising two integral components,
namely the encoder and the decoder, it operates by first directing the input
through the encoder to produce a latent code. This latent code subsequently
serves as the foundation for the decoder to generate the output. Thus, the
latent code assumes a pivotal role in the identification and disentanglement
of various sources of variation inherent within the input data. Through the
reduction of the latent code’s dimension, the autoencoder facilitates
effective dimension reduction, thereby yielding a more condensed and
meaningful representation of the input data. MMOT [22] utilizes the
autoencoder architecture to extract inherent patterns among workloads and then
uses these patterns to identify the model from similar workloads to generate
configurations.

###  5.2 Configuration-level Pruning

Another approach to mitigating the optimization time required by machine
learning-based methodologies is to reduce configuration space necessitating
tuning. Configuration-level pruning endeavors to discern and prioritize the
tuning of parameters that exert substantial influence on the DBMSs based on
historical observations.

  * •

Spearman Rank Correlation Coefficient (SRCC) [26]: is a nonparametric measure
of rank correlation on the strength of a monotonic relationship between paired
data. It is defined as the Pearson correlation coefficient between the rank
variables. By leveraging its capacity to gauge monotonic relationships, SRCC
facilitates the identification and removal of redundant parameters,
contributing to a more efficient and simplified configuration. LOCAT [7]
calculates SRCC between each configuration parameter and the workload
execution time to filter out some redundant configuration parameters and
narrow down the parameter search space.”

  * •

Principal Component Analysis (PCA): is a dimensionality reduction method that
transforms correlated variables into uncorrelated ones, known as principal
components. It does so by calculating the covariance matrix, performing
eigendecomposition, and selecting a subset of principal components based on
their variance. After SRCC, LOCAT [7] applies Gaussian kernel Principal
Component Analysis (KPCA) to further extract and form new lower-dimensional
parameters derived after removal of redundant configuration parameters for
subsequent optimal parameter searching.

  * •

Least Absolute Shrinkage and Selection Operator (LASSO) and Lasso Path
Algorithm. In the context of linear regression, LASSO modifies this objective
function by adding a $\mathit{L_{1}}$ penalty term equals to $\lambda$ times
the sum of absolute values of the regression coefficients, where $\lambda$
controls the strength of the penalty, and it helps to reduce the effect of
irrelevant variables by penalizing models with large weights. A higher
$\lambda$ value results in more coefficients being pushed toward zero, thereby
achieving interpretable, stable, and computationally efficient feature
selection. OtterTune [8] uses the LASSO path algorithm to assess the
importance of configuration parameters by gradually reducing the penalty term.
The order in which parameters are included during this process is then
considered as the importance order, and OtterTune uses this information to
prune less important parameters.

  * •

Random Forest (RF): is a supervised machine learning method to deal with
classification and regression problems. It can be deemed a voting algorithm
consisting of multiple decision trees, used to calculate the importance of
features. In the study [27], the authors utilize Latin Hypercube Sampling
(LHS) to select a subset of configurations. Subsequently, they employ Random
Forests with 300 Classification and Regression Trees (CART) to ascertain the
importance of each parameter. Their findings reveal that when employing the
YCSB workload-A on Cassandra, optimizing just five parameters can yield
performance levels comparable to 99% of the best configurations attained
through extensive parameter tuning. HUNTER [13] adopt the RF classifier with
CARTs and adopts the majority voting principle to determine the importance of
the knobs. It then selects the top-20 knobs to reduce the configuration search
space in its tuning framework.

  * •

Hashing-enhanced Subspace BO (HeSBO) [28]: is a randomized low-dimensional
projection approach that operates by deducing the search space for Bayesian
Optimization-based solutions (discussed in Section 7.1). By utilizing two
uniform hash functions to construct the rows and signs of the random
projection matrix, it performs a count-sketch projection to transform the
original high-dimensional configuration space into lower-dimensional subspace.
This process is intuitively designed to effectively preserve the
characteristics, such as pairwise point distances, of the original high-
dimensional space for the reduced (important) dimensions. LlamaTune [16]
adopts it to perform a projection of the configuration space from all
documentations to a lower-dimensional subspace and then use the Bayesian
Optimization-based optimizer to tune this smaller subspace.

  * •

Alternative approaches: Due to the challenges of tuning in high-dimensional
configuration spaces, the identification of parameters that significantly
affect DBMS performance has gained considerable attention. Among them,
Researchers in [29] propose Caver to select a subset of storage parameters.
Given a set of initial parameters and configurations, Carver first employs LHS
to select a small number of configurations for evaluation. Subsequently, it
greedily selects the most important parameters based on their parameter
importance values. The first parameter is determined by the highest importance
value, after which Carver fixes its value and computes the parameter
importance values for the remaining parameters. During this process,
importance is calculated as the difference between the variance of the
original set of configurations and the sum of variances within the subset when
parameters take different values. The algorithm selects parameters with the
maximum difference.

Recently, OpAdviser [30] proposed constructing an effective configuration
region that contains promising configurations. It leverages performance
similarity among historical workloads to guide the construction process.
Specifically, it extracts a relatively compact region based on similar
workloads and a larger region based on less similar ones. Furthermore,
OpAdviser constructs the target search space by employing a majority weighted
voting strategy to aggregate suggestions from candidate tasks.

###  5.3 Summary

Given the complex configuration space and the diversity of workloads,
employing pruning techniques to reduce workload running time and configuration
search space emerges as a natural approach in addressing these complexities.
In this section, we aim to provide direction for future practitioners and
researchers on improving data collection efficiency and training efficiency
through various pruning strategies. Specifically, we classify the pruning
techniques into two levels: workload-level and configuration space. Regarding
the workload level, we categorize it into two directions: eliminating
redundant queries and workload feature reduction techniques. For the
configuration level, we present the existing feature reduction methods applied
in the state-of-the-art tuning methods, mainly focusing on feature projection,
importance ranking, or feature clustering.

Moreover, future researchers and practitioners can also try to explore
different dimensionality reduction techniques tailored to specific data
characteristics, as outlined in the survey by Hou et al. [31]. Furthermore,
advancements in high-dimensional data technology offer opportunities to
enhance the performance of feature pruning methods. For instance, Yang et al.
[32] proposed an innovative variant of LASSO, named Efficient Tuning of Lasso
(ET-Lasso), which focuses on ensuring feature selection consistency. This
method has demonstrated effectiveness in efficiently selecting active features
contributing to the response, achieved by integrating permuted features as
pseudo-features within linear models.

##  6 Knowledge from Experience

As the process of finding the optimal configuration can be complex and time-
consuming, a natural and common approach is to draw insights from previous
workloads with similar characteristics and leverage that experience to guide
the tuning algorithm in configuring the target workload. Existing aspects can
be considered for learning from historical tuning experience, including:

  * •

Euclidean distance-based workload similarity: Euclidean distance calculates
the straight-line distance between two points in Euclidean space. It is
commonly used in machine learning tasks, such as clustering, classification,
and regression, to measure the similarity or dissimilarity. OtterTune [8]
applies it to match the target DBMS’s workload with the most similar workload
in its repository based on the performance measurements for the selected group
of metrics and then reuses the data from the selected workload to train a GP
model on the target metric for configuration recommendation.

  * •

Epanechnikov quadratic kernel-based workload similarity: The Epanechnikov
quadratic kernel function, denoted as $K(u)$, is defined as
$K(u)=\frac{3}{4}(1-u^{2})$ where the normalized distance $u$ is typically
computed as the difference between the coordinates of two points divided by
the bandwidth parameter. ResTune [6] employs it to identify similar historical
workloads in its initial tuning stage when there are only limited tuning
observation data available for tuning.

  * •

Cosine similarity: provides a straightforward and efficient method to measure
the similarity between two vectors in a multidimensional space by calculating
the cosine of the angle between these vectors. MMOT [22] adopts it to
determine the model for the target workload by selecting from trained DDPG-
based RL models based on workload similarity.

  * •

Performance surface similarity: works based on the consideration that similar
tasks may exhibit comparable trends in terms of where the objective is
minimized within the configuration space. It is calculated according to the
misranked performance of pairs of given configurations. ResTune [6] and
OpAdviser [30] identify workload similarity according to the ranking loss of
two workloads on a given configuration dataset, utilizing the observed
configurations and their corresponding performance as a benchmark. For every
pair of configurations, if the ranking of the predicted performance pair does
not match the observed pair, the rank loss (count of misranked pairs) is
incremented by 1. Finally, the ranking loss for this selected model is defined
as the total number of misranked pairings. The smaller the ranking loss, the
more similar the selected model is to the target model.

In the realm of DBMS automatic tuning, knowledge transfer mainly serves two
purposes: reducing the need for extensive training data collection and
minimizing model training duration. By leveraging this approach, tuning
algorithms can implicitly and explicitly utilize extracted knowledge. During
the tuning phase, the tuning model can leverage historical data collected from
similar workloads (implicitly) or directly apply extracted knowledge, such as
ensembling trained models or selecting pre-trained models (explicitly).

##  7 Configuration Recommendation

In this section, we embark on an exploration of automatic parameter
recommendation methodologies within the realm of DBMSs, categorizing them into
four principal domains: Bayesian Optimization, Reinforcement Learning, Neural
Network Solutions, and Search-based Solutions. Each classification encompasses
a diverse array of methodologies and techniques, each meticulously designed to
address specific nuances and challenges encountered within varying DBMS
environments and scenarios.

###  7.1 Bayesian Optimization

Bayesian Optimization (BO) leverages Bayesian Theorem to direct an efficient
and effective search of a global optimization problem. It minimizes/maximizes
an objective function $\mathit{f}$ iteratively through adaptive sampling of
the search space. BO has two key components: surrogate model and acquisition
function. The surrogate model captures the behavior of the objective function
$\mathit{f}$, while the acquisition function guides the selection of the next
sample. BO iteratively updates its surrogate model using samples chosen by the
acquisition function, ultimately identifying the minimal or maximal value of
$\mathit{f}$.

Surrogate models can be various machine learning models [33], such as Random
Forest (RF) [34] and Gaussian Process (GP) models [35], Bayesian neural
networks [36] or tree parzen estimators [37]. Among them, GP is a popular
surrogate model for objective modeling in BO due to its expressiveness and
well-calibrated uncertainty estimates, supporting for noisy observations. GP
provides confidence bounds on its predictions to model the objective function
with limited samples [3]. Regarding acquisition functions, popular choices
include expected improvement (EI) [38], probability of improvement (PI) [39],
and GP upper confidence bound (GP-UCB) [40] or entropy search [41], with EI
being the most widely utilized. Sequential Model-based Algorithm Configuration
(SMAC) [34] is a popular variant of BO-based solutions that uses a random
forest as its surrogate model, which is known to perform well for high-
dimensional and categorical input. It supports all types of variables,
including continuous, discrete, and categorical features.

TABLE III: Comparison of BO-based tuning solutions.

Work | Acquisition | Surrogate Model | Highlights
---|---|---|---
Input features | Model | Initial design
LOCAT [7] | EI-MCMC |  Spark SQL configurations (15 selected important paramters) & data size |  GP |  3 samples generated by LHS |  -
OtterTune [8] | EI |  DBMS configurations (Incremental selection of important parameters ranked by LASSO) |  GP |  A set of prior observations from the most similar workload |  Increasing the variance of the noise parameter and add a smaller ridge term for each selected configuration
ResTune [6] | CEI |  DBMS configurations ( 14 knobs to optimize CPU, 6 knobs to optimize memory usage, and 20 knobs to optimize the I/O resource) |  3-GP |  A set of prior observations and a small set of known observations on the target task |  Ensembling the trained models of historical workloads (including 3 GP models for resource utilization, throughput, and latency, respectively)
REIM [19] | EI |  Spark SQL configurations (6 parameters controlling memory pools across Container, Application Framework, and JVM) & 3 empirical memory-related features |  GP |  4 samples generated using LHS and 4 noisy observations |  Incorporating empirical analytical statistics
ONLINETUNE [3] | UCB |  DBMS configuration & Workload dynamicity context (query arrival rate, query composition and three other features related to cardinality estimation and index building /dropping |  GP |  Safe configurations set |  Augmenting the GP kernel with extra context variables, through an additive kernel of context kernel and configuration kernel
LlamaTuneGP [16] | EI | Converted features by HeSBO (16) |  GP | 10 samples by LHS | Biased sampling
LlamaTuneSMAC [16] |  RF (SMAC)
CGPTuner [17] | GP-Hedge |  DBMS configurations (15 for MongoDB and 24 for Cassandra) and workload parameters (2-dimension) |  GP |  A set of random selected configurations |  Designing a multiplication kernel function that works over configuration and workload pairs

Bayesian optimization-based automatic parameter tuning solutions primarily
involve designing the models in terms of the acquisition function, surrogate
models, model inputs (i.e., system configurations and configuration
constraints), initial design of samples, as well as model update, to meet the
specific tuning objectives. In this section, we provide an overview of state-
of-the-art BO-based automatic tuning methods applied in DBMS tuning and BDAFs
to describe how BO is adopted in automatic parameter tuning. The summary of
different solutions can be seen in Table III.

####  7.1.1 BO-based solutions

LOCAT [7] proposes a BO-based approach to ascertain the optimal configurations
tailored for Spark SQL applications, with a particular focus on accommodating
variations in input data sizes. It begins by employing a workload-level
pruning model, known as Query Configuration Sensitivity Analysis (QCSA), to
eliminate configuration-insensitive queries within a workload. Meanwhile, it
conducts configuration-level pruning using the important configuration
parameters (IICP) model through a two-step process: configuration parameter
selection (CPS) and configuration parameter extraction (CPE). Subsequently,
LOCAT utilizes the BO model along with its proposed Datasize-Aware Gaussian
Process (DAGP), which characterizes the application’s performance as a
distribution of functions of configuration parameters and input data size to
recommend the optimal configuration. In its BO-based solution, it employs the
Expected Improvement (EI) with a Markov Chain Monte Carlo (EI-MCMC)
hyperparameter marginalization algorithm [42] as the acquisition function,
leveraging the proposed DAGP as the surrogate model. Regrading its initial
design, LOCAT incrementally constructs the GP model, initially starting with
three samples generated through Latin Hypercube Sampling (LHS). Each sample
includes information on execution time, configuration, and the corresponding
data size. Following each execution, the updated GP model assists BO in
selecting the next candidate configuration, aimed at minimizing the execution
time of a Spark SQL application.

OtterTune[8] proposes to initiate the BO-based solution for DBMS configuration
tuning through the observation data from similar workloads. Specially, it
first maps unseen DBMS workloads to previously observed workloads by measuring
the Euclidean distance between workloads and identifies the most similar
workload in its repository based on DBMS runtime metrics. In the next step,
OtterTune utilizes the selected similar workload observation data to train a
GP surrogate model and updates it with new observations of the target
workload. Meanwhile, in order to improve the model’s generalization ability on
the target workload, OtterTune incorporates some noisy data processing
techniques, including increasing the variance of the noise parameter for all
points in the GP model that OtterTune has not yet tried for this tuning
session and adding a smaller ridge term for each configuration that OtterTune
selects. Regarding the acquisition function, OtterTune adopts EI and it
consistently selects configurations with the greatest EI. Meanwhile Gradient
descent [25] is applied to identify the local optimum on the surface predicted
by the GP model, using data comprising the top-performing configurations
completed in the current tuning session and randomly selected configurations.

ResTune [6] introduces a Constrained Bayesian Optimization (CBO) solution,
which extends BO into an inequality-constrained setting to optimize resource
utilization without violating service-level agreement constraints during the
DBMS configuration tuning process. Specifically, it models each DBMS tuning
task with a multi-output GP model which is composed of three independent GP
models, representing resource utilization, throughput, and latency
requirements. Meanwhile, ResTune introduces a Constrained Expected Improvement
(CEI) as its acquisition function. ResTune redefines the best configuration
point as the one with the lowest resource utilization while satisfying
throughput and latency constraints. CEI calculates the expected improvement of
a specific configuration over the best feasible point so far, weighted by the
probability that both throughput and latency satisfy the constraints.
Moreover, to expedite training, ResTune adopts an ensemble framework to learn
from experience by assembling pre-trained learners (GP models) from previous
tuning workloads in a weighted manner. In the initial tuning stage, it assigns
static weights to previous models based on the workload embedding features.
With sufficient observations collected, ResTune assigns dynamic weights
according to the ranking loss based on their performance surface similarity.

ReIM [19] introduces a BO-based solution tailored for the optimization of
memory-based analytics applications. In its framework, it utilizes GP as the
surrogate model with EI as the acquisition function. In terms of inputs for
the surrogate model, ReIM considers parameters encompassing both the
application configuration and a set of empirical analysis statistics related
to the objectives outlined by RelM. When searching, a combination of random
sampling and standard gradient-based search [43] is carried out to find the
highest EI.

ONLINETUNE [3] provides a BO-based solution for online tuning for DBMSs,
addressing safety and dynamicity concerns during the tuning process by adding
a dynamic context to the tuning task and narrowing down the search space to a
safe configuration search subspace. Specifically, it augments the surrogate
model GP with dynamic context variables, including workload dynamicity
characteristics based on query arrival rate and query composition, as well as
the underlying data distribution, in conjunction with DBMS configurations from
historical observations. Additionally, it constructs an additive kernel by
incorporating a linear kernel to model the dependencies among contexts and a
Martin kernel to capture the nonlinear performance associated with
configurations, premising that performance correlations emerge when
configurations and contextual factors exhibit similarities. ONLINETUNE adopts
the Upper Confidence Bound (UCB) [44] as its acquisition function, aiming to
improve the mean estimate of the underlying function and decrease the
uncertainty at candidate configurations to the maximum. Moreover, it unifies
two sampling criteria: UCB method, which selects configurations with maximal
confidence interval upper bound safety, and the Highest Uncertainty Boundary
(HUB) method, which selects safe configurations at the boundary of the safety
set with the highest uncertainty, according to the epsilon-greedy policy [45].

Regrading its safe configuration search subspace, it first constructs a
candidate configuration set by identifying a safe configuration subspace near
the initial safety configuration (default configuration) and adjusts it
iteratively, alternating between a hypercube and a line region towards the
global optimum. It then discretizes the adapted subspace to build the
candidate set. After that, the safety of each candidate is assessed based on
the confidence bounds of the contextual GP (black-box knowledge) and the
existing domain knowledge (white-box knowledge, e.g., MysqlTuner) to further
remove some unsafe or unpromising configuration candidates. Finally, to
address the inherent cubic computation complexity of the GP model, it employs
the DBSCAN clustering algorithm [46] to classify historical observations into
different clusters based on their context and trains a GP model for each
cluster. Then, SVM is applied to learn the boundary for each model, mapping
each new observation to its respective GP model.

LlamaTune [16] introduces a framework aimed at leveraging domain knowledge to
enhance the sample efficiency of existing BO-based automatic DBMS
configuration solutions and RL-based solutions. Initially, it employs a
randomized projection technique, HeSBO, to project the configuration space
from all documentations into a lower-dimensional subspace. Subsequently, the
tuning process is initialized within this constructed subspace. In the context
of BO-based solutions, LlamaTune adopts two BO-based frameworks: SMAC [47] and
GP-based BO [48]. Initially, a space-filling sampling method (e.g., LHS) is
employed to generate an initial set of points for training the surrogate
model. The model then suggests a candidate point maximizing the acquisition
function EI. Furthermore, LlamaTune implements various strategies for knob
selection and knob discretization. LlamaTune introduces a novel biased-
sampling approach, assigning a higher probability to special values such as
(i) disabling certain features, (ii) inferring a knob’s value based on another
knob, or (iii) setting a knob’s value using an internal heuristic or
predefined value during the random initialization phase. Additionally, it
employs bucketization of the knob value space at fixed intervals, limiting the
number of unique values any configuration knob can take up to a threshold to
reduce the configuration space.

CGPTuner [17] provides a BO-based online tuning solution for DBMSs,
considering the IT stack diversity (the operating systems and Java virtual
machine) to which the system is exposed. It addresses the IT stack diversity
with the Contextual Gaussian Process Bandit Optimization framework, which is a
contextual extension to the Bayesian Optimization framework. Specifically, it
utilizes GPs as surrogate models, a multiplication combination of two Matérn
5/2 kernels to model the configuration space and the workload space. For the
acquisition function, it follows the GP-Hedge approach [39], which, instead of
focusing on a specific acquisition function, adopts a portfolio of acquisition
functions governed by an online multi-armed bandit strategy, aiming to
progressively select the best acquisition function according to its previous
performance at each tuning iteration. Its workload characterisation is
conducted by an external workload characterisation module, such as the
workload characterisation provided by Ottertune [8], Peloton [49] or even a a
reaction-based characterisation used in compiler autotuning [50]

####  7.1.2 Summary

In Bayesian Optimization-based solutions, a critical aspect lies in the
careful selection and design of tailored components for BO models,
encompassing the acquisition function, surrogate model, and model
initialization, among others. Table III provides a comparative analysis in
these dimensions. Concerning the acquisition function, a prevalent choice
among researchers is EI, and some researchers also tried UCB and GP-Hedge. In
the realm of surrogate models, GP emerges as a prominent selection, while SMAC
exhibits capabilities in supporting diverse parameter types (continuous,
categorical, and conditional) and has demonstrated efficacy in managing the
intricacies of high-dimensional and heterogeneous configuration spaces. In
terms of sample design, practitioners and researchers can try constructing
samples from different aspects, including established techniques like random
sampling and LHS, alongside the potential for tailoring samples to specific
workload patterns or user-provided sample sets. Moreover, practitioners or
researchers can also look into refining kernel designs and employing noise
data processing strategies within the ambit of model design.

Owing to the training complexity, another crucial consideration is to
accelerate the tuning process from data collection and model training. For
each configuration execution, acceleration can be achieved through feature
pruning, encompassing workload-level pruning and configuration-level pruning.
In terms of model training to enhance the coverage process, BO-based solutions
are designed to adopt appropriate sampling techniques and transfer knowledge
from experience. Regarding task workload modeling, the task workload can be
modeled by training a GP model based on historical tuning observations or by
building separate GP models for other workloads and ensembling them together
for the target task. Currently, extensive research has been conducted on
determining the weight in ensembling GP models in Bayesian optimization [33,
51, 52, 53, 54, 55, 56].

###  7.2 Neural Network

Neural Network (NN)-based Solutions for automatic tuning leverage the power of
artificial neural networks to model the complex relationships between
configuration parameters and system performance, enabling efficient tuning
without the need for exhaustive search or manual intervention.

####  7.2.1 NN-based solutions

Tan et al. propose iBTune [15], individualized buffer tuning, to automatically
reduce the buffer size for any individual database instance while still
maintaining the quality of service for its response time. It leverages
information from similar workloads to determine the tolerable miss ratio of
each instance. Then, it utilizes the relationship between miss ratios and
allocated memory sizes to individually optimize the target buffer pool sizes
based on a large deviation analysis for the LRU caching model. To provide a
guaranteed level of service level agreement (SLA), it designs a pairwise deep
neural network (DNN) that predicts the upper bounds of the request response
time by learning features from measurements on pairs of instances.
Specifically, in the training phase, the NN network takes input of the
performance metrics (logical reads, I/O reads, queries per second (QPS), CPU
usage, miss ratio) of the target database instance and a similar database
instance, the response time (RT) of the similar instance, and the encoding of
the current time. The output of the network is the RT. In the testing phase,
the previously observed sample of the target is selected as the similar
instance. If the predicted RT meets the requirement, the computed new buffer
pool size is sent for execution.

Authors in [14] proposed Ottertune-DNN by adopting the OtterTune framework [8]
and replacing its gaussian process model with a neural network model. Same to
Ottertune [8], the raw data for each previous workload is collected and
compared with the target workload. Data from the most similar previous
workload are then merged with the target workload data to train a neural
network model, which replaces the GP model in the original OtterTune. Finally,
the algorithm recommends the next configuration to run by optimizing the
model. The neural network model is a stacked 2-layer neural network with 64
neurons connected using ReLU as the activation function, and there is one
dropout layer among the two hidden layers. Additionally, Gaussian noise is
added to the neural network parameters to control the trade-off between
exploration and exploitation, with increased exploitation throughout the
tuning session achieved by reducing the scale of the noise.

LITE [21] achieves configuration tuning for Spark applications by leveraging
the power of NN to analyze the application code semantics as well as
scheduling information during its execution. Its framework consists of an
offline training phase to estimate the performance of a Spark application for
a given knob configuration, and an online recommendation phase to recommend
appropriate knobs for a given Spark application. In the offline training
phase, LITE proposes a code learning framework, Neural Estimator via Code and
Scheduler representation (NECS), which extracts stage-level code and Directed
Acyclic Graph (DAG) Scheduler as training features. These features are then
concatenated with configuration features (knob values), data features, and
computing environment features as inputs to predict execution time by an MLP
(Multi-Layer Perceptron) module. In its online recommendation phase, LITE
introduces an Adaptive Candidate Generation module to initially construct a
configuration set. This process involves utilizing a Random Forest Regression
(RFR) model to ascertain the center of the promising knob range, which is
determined based on factors such as the input data size and the specific
application under consideration. Subsequently, the module establishes the knob
searching boundary, derived from the input data. Once these boundaries are
defined, the module randomly samples a small number of candidates from the
selected search space. Finally, it evaluates the performance of each candidate
configuration using the NECS model and recommends the knob values associated
with the best-estimated performance. Meanwhile, NECS designs an Adaptive Model
Update model to periodically fine-tunes the NECS model through adversarial
learning when a predefined batch of new instances are collected.

####  7.2.2 Summary

Neural network solutions offer distinct advantages in capturing complex
patterns and relationships between variables, particularly adept at handling
large and high-dimensional data spaces. Conversely, Bayesian Optimization can
incur computational overhead as the parameter space expands, owing to its
reliance on surrogate models such as Gaussian Processes. Regarding training
data, Bayesian Optimization is renowned for its data efficiency, rendering it
suitable for scenarios characterized by limited historical data availability.
In contrast, neural network-based solutions necessitate a more substantial
amount of data for training, yet they can yield more precise predictions once
trained. However, it is worth noting that they may entail a significant time
cost in cloud database tuning due to the acquisition of training data.

###  7.3 Reinforcement Learning

Reinforcement Learning (RL) is a subfield of machine learning where an agent
learns to make sequential decisions by interacting with an environment. In RL,
the agent, often represented as an algorithm or program, seeks to develop a
strategy or policy that enables it to maximize a cumulative reward over time.
The learning process involves the agent navigating through different states,
taking actions based on the policy (a mapping from perceived states of the
environment to actions to be taken when in these states), receiving feedback
in the form of rewards, and updating the policy. The ultimate goal is to
obtain an optimal policy by learning from experiences. Currently, RL has
gained more popularity in various areas, including games [57, 58], robotics
[59, 60], natural language processing [61, 62, 63], healthcare [64, 65],
finance [66, 67], business management [68, 69], transportation [70, 71], etc.

According to the methods used to determine the policy, RL can be classified
into two three categories: (1) Value-based RL, which aims to learn the value
or benefit (commonly referred to as Q-value) of all actions and selects the
action corresponding to the highest value. Among them, Q-Learning [72] is a
classic example of a value-based algorithm where the agent learns a Q-value
for each action in each state. The optimal policy is then derived from these
learned Q-values. (2) Policy-based RL takes a different approach by directly
learning the optimal policy. Typically, a parameterized policy is chosen,
whose parameters are updated to maximize the expected return using either
gradient-based or gradient-free optimization [73]. In comparison to value-
based algorithms, policy-based approaches are effective for high-dimensional
or continuous action spaces and can learn stochastic policies, which are more
practical than deterministic policies in value-based RL.

Currently, the actor-critic framework has gained popularity as an effective
means of combining the benefits of policy-based approaches with value-based
approaches. In this framework, the ‘actor’ (policy) estimates the target
policy and take an action under a specific state, while the ‘critic’ network
(value function) approximates the state-value function to evaluate the current
policy. One notable development [73] in the context of actor-critic algorithms
is deterministic policy gradients (DPGs) [74], which extend the standard
policy gradient theorems for stochastic policies to deterministic policies.
Following the success of using deep convolutional neural networks to
approximate the optimal action-value function in Deep Q-Networks (DQN) [58],
the Deep Deterministic Policy Gradient (DDPG) [75] utilizes neural networks
within the DPG framework to operate on high-dimensional visual state spaces.

To address the challenge of optimizing performance in large configuration
spaces with limited historical data, researchers have proposed RL-based
methods. These approaches leverage RL’s capability to explore the
configuration space through trial-and-error strategies without being
constrained by the number of configuration parameters. The main challenge of
using RL in knob tuning is to design the five modules in RL as shown in Table
IV. Generally, the DBMS instance is normally considered as the
$\mathit{environment}$, and the DBMS configuration is treated as the
$\mathit{action}$ in the environment, $\mathit{agent}$ can be seen as the
tuning model which receives $\mathit{reward}$, (DBMS performance, such as
throughout $T$ and latency $L$) and state (a set of pre-selected database
monitors) from DBMSs and updates the $\mathit{policy}$ to guide how to adjust
the knobs for getting higher reward (higher performance). and the DBMS
configuration vector represents the state resulting from each action. These
configurations will be evaluated based on the tuning performance objective,
serving as the reward. Table V provides an overview of state-of-the-art RL-
based configuration tuning solutions applied in DBMS and BDAF.

TABLE IV: RL for DBMS configuration parameter tuning Terms in RL | Terms in DBMS
---|---
Agent |  The RL model, which receives reward (i.e., the performance change) and state from the DB instance and updates the policy to guide how to adjust the knobs for getting a higher reward.
State |  State means the current state of the agent, i.e., the DBMS running time internal metrics.
Environment |  A DBMS instance.
Reward |  Reward $r$ is a scalar indicating the objective performance of executing a workload, such as throughput $T$ and latency $L$ or their changes.
Action |  Action comes from the space of knob configurations and represents a knob tuning operation.
Policy |  Policy defines the behavior of the RL model at a certain specific time and environment, which is a mapping from state to action.
TABLE V: Comparison of RL-based solutions

Work | State | Policy | Reward Function | Highlights
---|---|---|---|---
CDBTune [12] |  DBMS internal metrics | DDPG |  $r=\alpha f(\Delta T_{t\to 0},\Delta T_{t\to t-1})+\beta f(\Delta L_{t\to 0},\Delta L_{t\to t-1})$ |  Random Sampling on sample selection
LlamaTuneRL [16] |  DBMS internal metrics | DDPG |  Same as CDBTune |  Configuration space projection, biased sampling
Qtune [9] |  DBMS internal metrics | DS-DDPG |  Same as CDBTune |  Incorporating query features
MMOT [22] |  DBMS internal metrics | Multiple DDPG |  $r=\alpha\Delta T_{t\to 0}+\beta\Delta L_{t\to 0}$ |  Prioritized model selection, Gaussian exploration noise
WATuning [23] |  DBMS internal metrics | DDPG with attention |  $r=\alpha f(\Delta T_{t\to 0},\Delta T_{t\to t-1})+\beta f(\Delta L_{t\to 0},\Delta L_{t\to t-1})$ or 0 |  State feature importance
HUNTER [13] |  DBMS internal metrics | DDPG with FES |  $r=\alpha\Delta T_{t\to 0}+\beta\Delta L_{t\to 0}$ |  GA sampling, metric compression and knob reduction, and FES on action selection
DB-BERT [18] |  hint-related parameter operations | Double DQN |  $r=|T_{0}-T|$ or -1000 |  BERT-based manual analysis

####  7.3.1 RL-based Solutions

CDBTune [12] handles the continuous parameter space and unseen dependencies
among parameters by adopting DDPG. In CDBtune, the DBMS instance to be tuned
is treated as the environment, with the DBMS internal metric vector (such as
INNODB_METRICS [24]) representing the state from the environment and each DBMS
configuration vector as an action. Then, the tuning agent generates a
configuration and receives a reward (consisting of objective performance
metrics) after deploying it on the DBMS instance. CDB designs its reward
function by considering both throughput and latency across different phases,
including the initial tuning state, the previous action, as well as the
current action. In this framework, DDPG has a parameterized policy neural
network that maps the state to the action, and the critic neural network aims
to represent the value (score) associated with a specific action and state,
guiding the learning of the actor. Meanwhile, CDBtune can learn from past
experiences through experience replay in DDPG, which stores past experiences
(state, action, reward, next state) in a replay buffer and samples them
randomly during the learning process.

LlamaTuneRL [16] introduces a framework aimed at leveraging domain knowledge
to enhance the sample efficiency of existing BO-based automatic DBMS
configuration solutions. Similar to its BO-based solutions, LlamaTuneRL
employs HeSBO to project the configuration space into a low-dimensional
subspace and conducts the same biased sampling knob selection and knob
discretization strategies. It integrates the RL framework from CDBTune [12],
utilizing DDPG as its policy function. The converted knob features serve as
its states, while throughput/latency metrics are utilized as the reward in the
RL framework.

Qtune [9] provides a query-level parameter tuning system with a RL-based
framework to tune the database configurations. QTune first featurizes the SQL
queries by considering rich features of the SQL queries, including query type
(insert/delete/update/select), tables, and query cost (generated from the
query optimizer in terms of scan, hash join, aggregate, etc.). Then QTune
feeds the query features into the DRL model to dynamically choose suitable
configurations. A Double-State Deep Deterministic Policy Gradient (DS-DDPG)
model is applied to enable query-aware database configuration tuning, which
utilizes the actor-critic networks to tune the database configurations based
on both the query vector and database states.

MMOT [22] introduces a multi-model online tuning algorithm employing RL to
effectively adapt to dynamic workloads, encompassing fluctuations in system
resources, workload diversity, and database size. Initially, it curates a
selection of trained DDPG-based RL models derived from historically similar
workloads. In each training iteration, the algorithm selects the model with
the highest probability of enhancing the reward from the repository and
updates it with the current observations. Moreover, it maintains a fresh RL
model trained exclusively on the target workload observations. To ensure
optimal model selection, models from the repository are pitted against the
fresh model. In the event of workload shifts, the most frequently selected
model within the workload cycle is retained in the repository. Throughout the
iterative process, all RL models employ DDPG as their policy function,
utilizing 22 PostgreSQL metrics from three different perspectives to define
the action space. Its reward function is degined to incorporate initial
throughput and latency, along with current observed performance in each
iteration. Meanwhile and it adds Gaussian action space exploration noise using
the Ornstein-Uhlenbeck procesess. Workload characterization is facilitated
through the application of a 3-layer autoencoder, enabling both similarity
model selection and model shift detection.

WATuning [23] is a workload-aware auto-tuning system specifically developed to
tackle the adaptability challenges posed by changes in workload
characteristics within CDBtune. It operates by using a multi-instance
mechanism that dynamically employs different trained models to suggest
parameter adjustments based on the workload’s write/read ratio during runtime.
Each instance model is equipped with an attention-based DDPG network, which
uses a deep neural network to create a weight matrix capturing the
significance of each state characteristic to the current workload. This
attention mechanism is integrated into the actor network, where it
collaborates with the critic network to determine the most optimal parameter
settings. The reward function is calculated based on performance improvements
observed in throughput and latency in the initial and last time, while also
considering deviations from optimal performance and server stability.
Meanwhile, it also offers the flexibility to adjust weights for throughput and
latency rewards according to user preferences.

HUNTER [13] proposed an online DBMS tuning system with a hybrid architecture,
utilizing samples generated by Genetic Algorithm (GA) to select warm-start
samples for the finer-grained exploration of deep reinforcement learning.
Subsequently, it employs Principal Component Analysis and Random Forest for
metric compression and knob selection, respectively. Deep Deterministic Policy
Gradients (DDPG) are then applied to learn and recommend the optimal
configuration based on dimension-reduced metrics and selected knobs.
Additionally, HUNTER introduced a Fast Exploration Strategy (FES) for DDPG,
involving a probabilistic action selection either on the action generated in
the current step or on the action that yields the best performance. This
strategy forces the model to select configurations with the best performance
in the preliminary stage of tuning and encourages exploration based on
relatively better configurations to reduce the update time of the learning
model.

DB-BERT [18] introduces a RL-based solution for DBMS parameters tuning,
leveraging insights extracted from textual sources such as manuals and
relevant documents. In its initial data processing phase, DB-BERT employs a
finetuned BERT Transformer model to identify and extract tuning hints from
textual data, and prioritized these hints with a heuristic approach, favoring
parameters frequently mentioned while ensuring a balanced consideration of
hints for each parameter. During the subsequent learning phase, DB-BERT
iteratively learns to translate, adapt, prioritize, and aggregate hints to
optimize DBMS performance through RF. In each iteration, DB-BERT considers a
batch of tuning hints. For each hint, it translates the hint text into a
simple equation, assigning a value to a parameter, and then decides whether to
deviate from the recommended value (adopt) and assigns a weight to the hint
(prioritize). Then, it aggregates them into a small set of configurations,
mediating between inconsistent recommendations using hint weights. From the
perspective of RL, the environment is defined by workload and system
properties. Actions within this environment empower the agent to adapt hints,
prioritize between different hints, and aggregate hints for evaluation in
trial runs. The performance observed during these trial runs, measured against
user-defined benchmarks, serves as a reward signal. This reward signal is then
utilized by the Double Deep Q-Networks (DDQN) reinforcement learning algorithm
to guide the selection of configurations in future iterations.

####  7.3.2 Summary

Compared to BO-based solutions and NN-based solutions, RL-based solutions
alleviate the difficulty of collecting data for models owing to their reward-
feedback mechanism. They learn the tuning strategy through interactions
between the database and tuning model, iteratively improving decision-making
over time. This makes RL particularly suitable for optimizing performance in
large configuration spaces with limited historical data, offering robust
performance in complex and uncertain environments.

Existing RL-based DBMS parameter tuning solutions primarily elucidate the
model design through four key aspects, as detailed in Table V: the policy
function for identifying optimal knob settings, the reward function for
evaluating selected configurations, candidate configuration searching, and
model training. To summarize, DDPG stands out as the predominant policy
function, given its proficiency in managing continuous parameter spaces.
Regarding reward function design, some researchers adhere to the CDBTune
reward function, which assesses the performance change of both throughput and
latency across various phases. Conversely, others may focus solely on
performance alterations during the initial phase or concentrate on a singular
performance metric. In terms of searching for candidate configurations, Hunter
introduced probabilistic action selection, either on the action generated in
the current step or on the action that yields the best performance.
Furthermore, researchers propose various methodologies concerning model
training, such as sample selection, configuration space transformation, and
the integration of supplementary information like tuning experience and state
importance into RL models.

###  7.4 Search-based Solutions

Search-based methods iteratively search for optimal configuration parameters
by evaluating the system’s performance under different configurations. The
core of search-based methods is to design the search strategy to handle the
tradeoff between exploration(searching broadly across the configuration space
to discover new and potentially promising regions) and exploitation
(intensively searching in regions believed to be promising based on the
available information).

BestConfig [10] recommends configuration parameters through an iterative
process consisting of the divide & diverge sampling for sample collection and
the recursive bound & search for configuration parameter recommendation.
Specifically, it first discretizes the parameter ranges for each parameter
into several intervals (divide), and then selects a set of samples by
considering each interval of a parameter once (diverge). In the recursive
bound & search phase, it starts by searching the point with the best
performance among the selected samples. Then, it searches from its surrounding
points for better performance (bound). If such point are found, it conducts
sampling around the new sample. This optimization process is iteratively
conducted until no point with better performance is found.

AutoTune [11] is an automatic parameter tuning system that aims to optimize
application execution time on big data analytics frameworks. It executes
experiments on both the production cluster and on a smaller-scale testbed to
perform more test runs. It consists of three main steps. First, AutoTune
executes the application using different data sizes and numbers of machines to
build a parametric model. The model is used to select the data and cluster
size for running the experiments within a time budget. The second step
involves (i) exploration via using latin hypercube sampling (LHS) for
generating different configurations to execute and (ii) exploitation via
building and employing a Random Forest model for finding promising
configurations to execute. In the final step, the best q configurations are
used for executing the application on the production and determining the best
one.

UDAO [20] considers the tuning problem as a principled multi-objective
optimization (MOO) approach that takes multiple, possibly conflicting,
objectives, computes a Pareto optimal set of configurations (i.e., not
dominated by any other configuration in all objectives), and returns one from
the set that best suits the objectives. To be specific, it incrementally
transforming a MOO problem to a set of constrained optimization (CO) problems,
where each CO problem can be solved individually to return a Pareto optimal
point.

##  8 Experimental Setting

In the realm of database performance optimization, a diverse array of open-
source benchmarks has emerged. These benchmarks encapsulate both data sets and
workloads, effectively emulating real-world database systems. Typically, they
are categorized into online transaction processing (OLTP) and online
analytical processing (OLAP). OLAP prioritizes complex data analysis and
reporting, whereas OLTP specializes in transactional processing and real-time
updates.

Typical OLTP benchmarks are listed as follows:

  * •

Sysbench111https://github.com/akopytov/sysbench: is a popular open source
scriptable multi-threaded benchmark tool based on LuaJIT. It provides a set of
modular, configurable tests that measure various aspects of system
performance, including CPU, memory, file I/O, and OLTP-like database
performance (supporting MySQL, MariaDB, PostgreSQL, SQLite, and others). It
offers various OLTP workloads designed to simulate different transaction
scenarios commonly encountered in online transaction processing systems. These
workloads include read-only, read-write, point-select, update-index, insert,
and delete operations, each assessing different aspects of database
performance such as concurrency, response times, and efficiency of data
manipulation.

  * •

TPC-C222https://www.tpc.org/TPC: This is the current industry standard for
evaluating the performance of OLTP systems. TPC-C involves a mix of 5
concurrent transactions of different types and complexity either executed on-
line or queued for deferred execution. The database is comprised of 9 types of
tables with a wide range of record and population sizes.

  * •

Wikipedia: This OLTP benchmark is derived from the software that runs the
popular on-line encyclopedia. Since the website’s underlying software,
MediaWiki, is open-source, the real schema, transactions, and queries used in
the live website are therefore available.

  * •

SEATS: The SEATS benchmark [76] models an airline ticketing system where
customers search for flights and make on-line reservations. It consists of
eight tables and six transaction types. Approximately 60% of the transactions
are read-only (e.g., customers searching for open seats), while the other 40%
involve creating, updating, and deleting reservation records.

  * •

YCSB: The Yahoo! Cloud Serving Benchmark (YCSB) [77] is modeled after data
management applications with simple work- loads and high scalability
requirements. It is comprised of six OLTP transaction types that access random
tuples based on a Zipfian distribution. The database contains a single table
with 10 attributes.

  * •

BenchBase333https://github.com/cmu-db/benchbase (formerly OLTPBench [78]) is a
Multi-DBMS SQL Benchmarking Framework via JDBC. This benchmark suite offers a
standardized set of workloads and metrics to assess the performance and
scalability of database systems, supporting transactional Benchmarks such as
TPC-C, TPC-H, TATP, SmallBank, SEATS, etc. as well as web-oriented benchmarks
such as Twitter, Wikipedia, etc., and feature testing benchmarks including
ResourceStresser (RS), YCSB, etc.

Typical OLAP benchmarks are listed as follows:

  * •

TPC-H444https://www.tpc.org/tpch/: TPC-H is a standard industry database
benchmark with 8 tables. It consists of a suite of business oriented ad-hoc
queries and concurrent data modifications. It is similar to TPC-DS that
simulates a decision support system workloads that simulates an OLAP
environment where there is little prior knowledge of the queries . It contains
8 tables in 3NF schema and 22 queries with varying complexity.

  * •

JOB555https://github.com/gregrahn/join-order-benchmark: Join Order Benchmark
(JOB) [79] is a comprehensive benchmarking framework, with a set of queries
over the Internet Movie DataBase (IMDB), designed to assess cardinality
estimation and query optimization strategies. The benchmark encompasses 113
multi-join query instances derived from 33 query templates, tailored to the
IMDB dataset. Each query is characterized by a varying number of joins,
ranging from 3 to 16, with an average of 8 joins per query. It has 3.6GB data
(11GB when counting indexes) and 21 tables.

  * •

TPC-DS666https://www.tpc.org/TPC containing 99 queries, has been widely used
in Spark SQL systems for research and development of optimization techniques
[80, 81, 82]. It models complex decision support functions to provide highly
comparable, controlled, and repeatable tasks in evaluating the performance of
Spark SQL systems.

  * •

The HiBench [83] is a big data benchmark suite that helps evaluate different
big data frameworks in terms of speed, throughput and system resource
utilizations. It contains a set of Hadoop, Spark and streaming workloads,
including Sort, WordCount, TeraSort, Repartition, SQL, etc. In its SQL related
benchmarks it contains three different kinds of queries: Join, Scan, and
Aggregation. Join is a query that typically executes in two phases: Map and
Reduce. Scan is a query that consists of only a Map operation initiated by the
”select” command, which splits the input value based on the field delimiter
and outputs a record. Aggregation is a query that consists of both Map and
Reduce operations. The Map operation (”select” command) first splits the input
value by the field delimiter and then outputs the field defined by the Reduce
operation (”group by” command) as a new key/value pair.

##  9 Related Work

Recently, the authors in [84] provided an experimental evaluation of several
BO-based solutions and RL-based solutions and demonstrated how hyper-parameter
optimization algorithms can be borrowed to further enhance database
configuration tuning. After that, the authors in [85] conducted a survey on
the state-of-the-art DBMS tuning methods, including heuristic methods,
Bayesian optimization methods, deep learning methods, and reinforcement
learning methods. They illustrated the automatic tuning pipeline ranging from
data preparation to configuration tuning.

In this study, in addition to elucidating the automatic tuning framework on
DBMSs, we provide an in-depth analysis of each component. Specifically, we
outline the primary tuning objectives and summarize three main constraints or
factors in automatic configuration tuning in DBMS: overhead, adaptivity, and
safety. Regarding workload characterization, we present methods for modeling a
workload in terms of queries and DBMS runtime metrics. In the feature pruning
section, we offer insights into pruning strategies at both the workload and
configuration levels. Concerning knowledge transfer, we consolidate existing
techniques and present two directions for adopting this knowledge. In the
subsequent configuration recommendation section, we provide an overview of
existing methods and highlight the available design considerations for each
category. Additionally, we include several relevant automatic tuning methods
that focus on big data analytics frameworks, which face similar challenges in
identifying the optimal configuration within the complex and interdependent
configuration space. Finally, in the experiment setting, we summarize popular
benchmarks for evaluating DBMS performance.

##  10 Discussion and Conclusion

This paper presents a comprehensive overview of predominant methodologies
utilized in the automatic tuning of parameters within database management
systems. The study explores a diverse array of configuration tuning
techniques, encompassing Bayesian optimization, Neural network-based
approaches, Reinforcement learning methodologies, and Search-based strategies.
By systematically dissecting the tuning process into discrete
components—comprising tuning objectives, workload characterization, feature
pruning, knowledge from experience, configuration recommendation, and
experimental settings—this research provides nuanced insights into the
strategic intricacies inherent within each phase.

Existing tuning methodologies have undergone extensive investigation into
parameter optimization pertaining to DBMS performance, integrating
considerations of overhead, adaptivity, and safety concerns. When addressing
this tuning task, one essential aspect is workload characterization. The
dynamic nature of on-demand cloud applications often necessitates more
intricate and varied requirements for the cloud database. These requirements
can enrich the application profiling process within the tuning framework,
facilitating the optimization of DBMS parameters. Additionally, another
essential aspect is data collection and search space reduction. Currently, ML-
based solutions, especially for BO and NN solutions, typically require
sufficient samples to bootstrap the tuning framework, which can be quite time-
intensive. Regarding search space reduction, automatic tuning of DBMS can
benefit from innovative research in the hyperparameter optimization problem
area, such as distributional variance among source datasets and target
datasets [86], as well as search space reduction techniques [87, 88]. Finally,
some other DBMS characteristics can also be considered in the tuning
framework, such as database scalability which elucidates performance
fluctuations in response to changes in resource capacity, and database
elasticity denoting the speed and precision with which a system adapts its
allocated resources to varying load intensities. They also emerge as critical
considerations in contemporary cloud computing environments [89, 90, 91, 92,
93].

## References

  * [1] Y.-L. Choi, W.-S. Jeon, and S.-H. Yoon, “Improving database system performance by applying nosql,” _Journal Of Information Processing Systems_ , vol. 10, no. 3, pp. 355–364, 2014.
  * [2] K. Sahatqija, J. Ajdari, X. Zenuni, B. Raufi, and F. Ismaili, “Comparison between relational and nosql databases,” in _2018 41st international convention on information and communication technology, electronics and microelectronics (MIPRO)_. IEEE, 2018, pp. 0216–0221.
  * [3] X. Zhang, H. Wu, Y. Li, J. Tan, F. Li, and B. Cui, “Towards dynamic and safe configuration tuning for cloud databases,” in _Proceedings of the 2022 International Conference on Management of Data_ , 2022, pp. 631–645.
  * [4] Z. Yan, J. Lu, N. Chainani, and C. Lin, “Workload-aware performance tuning for autonomous dbmss,” in _2021 IEEE 37th International Conference on Data Engineering (ICDE)_. IEEE, 2021, pp. 2365–2368.
  * [5] S. Duan, V. Thummala, and S. Babu, “Tuning database configuration parameters with ituned,” _Proceedings of the VLDB Endowment_ , vol. 2, no. 1, pp. 1246–1257, 2009.
  * [6] X. Zhang, H. Wu, Z. Chang, S. Jin, J. Tan, F. Li, T. Zhang, and B. Cui, “Restune: Resource oriented tuning boosted by meta-learning for cloud databases,” in _Proceedings of the 2021 international conference on management of data_ , 2021, pp. 2102–2114.
  * [7] J. Xin, K. Hwang, and Z. Yu, “Locat: Low-overhead online configuration auto-tuning of spark sql applications,” in _Proceedings of the 2022 International Conference on Management of Data_ , 2022, pp. 674–684.
  * [8] D. Van Aken, A. Pavlo, G. J. Gordon, and B. Zhang, “Automatic database management system tuning through large-scale machine learning,” in _Proceedings of the 2017 ACM international conference on management of data_ , 2017, pp. 1009–1024.
  * [9] G. Li, X. Zhou, S. Li, and B. Gao, “Qtune: A query-aware database tuning system with deep reinforcement learning,” _Proceedings of the VLDB Endowment_ , vol. 12, no. 12, pp. 2118–2130, 2019.
  * [10] Y. Zhu, J. Liu, M. Guo, Y. Bao, W. Ma, Z. Liu, K. Song, and Y. Yang, “Bestconfig: tapping the performance potential of systems via automatic configuration tuning,” in _Proceedings of the 2017 Symposium on Cloud Computing_ , SantaClara,CA,USA, 2017, pp. 338–350.
  * [11] L. Bao, X. Liu, and W. Chen, “Learning-based automatic parameter tuning for big data analytics frameworks,” in _2018 IEEE International Conference on Big Data (Big Data)_. IEEE, 2018, pp. 181–190.
  * [12] J. Zhang, Y. Liu, K. Zhou, G. Li, Z. Xiao, B. Cheng, J. Xing, Y. Wang, T. Cheng, L. Liu _et al._ , “An end-to-end automatic cloud database tuning system using deep reinforcement learning,” in _Proceedings of the 2019 International Conference on Management of Data (ICDM)_ , 2019, pp. 415–432.
  * [13] B. Cai, Y. Liu, C. Zhang, G. Zhang, K. Zhou, L. Liu, C. Li, B. Cheng, J. Yang, and J. Xing, “Hunter: an online cloud database hybrid tuning system for personalized requirements,” in _Proceedings of the 2022 International Conference on Management of Data_ , 2022, pp. 646–659.
  * [14] D. Van Aken, D. Yang, S. Brillard, A. Fiorino, B. Zhang, C. Bilien, and A. Pavlo, “An inquiry into machine learning-based automatic configuration tuning services on real-world database management systems,” _Proceedings of the VLDB Endowment_ , vol. 14, no. 7, pp. 1241–1253, 2021.
  * [15] J. Tan, T. Zhang, F. Li, J. Chen, Q. Zheng, P. Zhang, H. Qiao, Y. Shi, W. Cao, and R. Zhang, “ibtune: Individualized buffer tuning for large-scale cloud databases,” _Proceedings of the VLDB Endowment_ , vol. 12, no. 10, pp. 1221–1234, 2019.
  * [16] K. Kanellis, C. Ding, B. Kroth, A. Müller, C. Curino, and S. Venkataraman, “Llamatune: sample-efficient dbms configuration tuning,” _arXiv preprint arXiv:2203.05128_ , 2022.
  * [17] S. Cereda, S. Valladares, P. Cremonesi, and S. Doni, “Cgptuner: a contextual gaussian process bandit approach for the automatic tuning of it configurations under varying workload conditions,” _Proceedings of the VLDB Endowment_ , vol. 14, no. 8, pp. 1401–1413, 2021.
  * [18] I. Trummer, “Db-bert: a database tuning tool that” reads the manual”,” in _Proceedings of the 2022 international conference on management of data_ , 2022, pp. 190–203.
  * [19] M. Kunjir and S. Babu, “Black or white? how to develop an autotuner for memory-based analytics,” in _Proceedings of the 2020 ACM SIGMOD International Conference on Management of Data_ , 2020, pp. 1667–1683.
  * [20] F. Song, K. Zaouk, C. Lyu, A. Sinha, Q. Fan, Y. Diao, and P. Shenoy, “Spark-based cloud data analytics using multi-objective optimization,” in _2021 IEEE 37th International Conference on Data Engineering (ICDE)_. IEEE, 2021, pp. 396–407.
  * [21] C. Lin, J. Zhuang, J. Feng, H. Li, X. Zhou, and G. Li, “Adaptive code learning for spark configuration tuning,” in _2022 IEEE 38th International Conference on Data Engineering (ICDE)_. IEEE, 2022, pp. 1995–2007.
  * [22] Y. Gur, D. Yang, F. Stalschus, and B. Reinwald, “Adaptive multi-model reinforcement learning for online database tuning.” in _EDBT_ , 2021, pp. 439–444.
  * [23] J.-K. Ge, Y.-F. Chai, and Y.-P. Chai, “Watuning: a workload-aware tuning system with attention-based deep reinforcement learning,” _Journal of Computer Science and Technology_ , vol. 36, no. 4, pp. 741–761, 2021.
  * [24] M. 8.0, “Innodb information_schema metrics table,” https://dev.mysql.com/doc/refman/8.0/en/innodb-information-schema-metrics-table.html, 2023.
  * [25] T. Hastie, R. Tibshirani, J. H. Friedman, and J. H. Friedman, _The elements of statistical learning: data mining, inference, and prediction_. Springer, 2009, vol. 2.
  * [26] J. H. Zar, “Spearman rank correlation,” _Encyclopedia of biostatistics_ , vol. 7, 2005.
  * [27] K. Kanellis, R. Alagappan, and S. Venkataraman, “Too many knobs to tune? towards faster database tuning by pre-selecting important knobs,” in _12th USENIX Workshop on Hot Topics in Storage and File Systems (HotStorage 20)_ , 2020.
  * [28] A. Nayebi, A. Munteanu, and M. Poloczek, “A framework for bayesian optimization in embedded subspaces,” in _International Conference on Machine Learning_. PMLR, 2019, pp. 4752–4761.
  * [29] Z. Cao, G. Kuenning, and E. Zadok, “Carver: Finding important parameters for storage system tuning,” in _18th USENIX Conference on File and Storage Technologies (FAST 20)_ , 2020, pp. 43–57.
  * [30] X. Zhang, H. Wu, Y. Li, Z. Tang, J. Tan, F. Li, and B. Cui, “An efficient transfer learning based configuration adviser for database tuning,” _Proceedings of the VLDB Endowment_ , vol. 17, no. 3, pp. 539–552, 2023.
  * [31] C. K. J. Hou and K. Behdinan, “Dimensionality reduction in surrogate modeling: A review of combined methods,” _Data Science and Engineering_ , vol. 7, no. 4, pp. 402–427, 2022.
  * [32] S. Yang, J. Wen, X. Zhan, and D. Kifer, “Et-lasso: a new efficient tuning of lasso-type regularization for high-dimensional data,” in _Proceedings of the 25th ACM SIGKDD international conference on knowledge discovery & data mining_, 2019, pp. 607–616.
  * [33] T. Bai, Y. Li, Y. Shen, X. Zhang, W. Zhang, and B. Cui, “Transfer learning for bayesian optimization: A survey,” _arXiv preprint arXiv:2302.05927_ , 2023.
  * [34] F. Hutter, H. H. Hoos, and K. Leyton-Brown, “Sequential model-based optimization for general algorithm configuration,” in _Learning and Intelligent Optimization: 5th International Conference, LION 5, Rome, Italy, January 17-21, 2011. Selected Papers 5_. Springer, 2011, pp. 507–523.
  * [35] M. Seeger, “Gaussian processes for machine learning,” _International journal of neural systems_ , vol. 14, no. 02, pp. 69–106, 2004.
  * [36] J. Snoek, O. Rippel, K. Swersky, R. Kiros, N. Satish, N. Sundaram, M. Patwary, M. Prabhat, and R. Adams, “Scalable bayesian optimization using deep neural networks,” in _International conference on machine learning_. PMLR, 2015, pp. 2171–2180.
  * [37] J. Bergstra, R. Bardenet, Y. Bengio, and B. Kégl, “Algorithms for hyper-parameter optimization,” _Advances in neural information processing systems_ , vol. 24, 2011.
  * [38] D. R. Jones, M. Schonlau, and W. J. Welch, “Efficient global optimization of expensive black-box functions,” _Journal of Global optimization_ , vol. 13, pp. 455–492, 1998.
  * [39] M. Hoffman, E. Brochu, N. De Freitas _et al._ , “Portfolio allocation for bayesian optimization.” in _UAI_ , 2011, pp. 327–336.
  * [40] C. E. Rasmussen, “Gaussian processes in machine learning,” in _Summer school on machine learning_. Springer, 2003, pp. 63–71.
  * [41] P. Hennig and C. J. Schuler, “Entropy search for information-efficient global optimization.” _Journal of Machine Learning Research_ , vol. 13, no. 6, 2012.
  * [42] J. Snoek, H. Larochelle, and R. P. Adams, “Practical bayesian optimization of machine learning algorithms,” _Advances in neural information processing systems_ , vol. 25, 2012.
  * [43] J. Mockus, _Bayesian Approach to Global Optimization Theory and Applications_ , 1989.
  * [44] N. Srinivas, A. Krause, S. M. Kakade, and M. Seeger, “Gaussian process optimization in the bandit setting: No regret and experimental design,” _arXiv preprint arXiv:0912.3995_ , 2009.
  * [45] V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller, “Playing atari with deep reinforcement learning,” _arXiv preprint arXiv:1312.5602_ , 2013.
  * [46] M. Ester, H.-P. Kriegel, J. Sander, X. Xu _et al._ , “A density-based algorithm for discovering clusters in large spatial databases with noise,” in _kdd_ , vol. 96, no. 34, 1996, pp. 226–231.
  * [47] M. Lindauer, K. Eggensperger, M. Feurer, A. Biedenkapp, D. Deng, C. Benjamins, T. Ruhkopf, R. Sass, and F. Hutter, “Smac3: A versatile bayesian optimization package for hyperparameter optimization,” _The Journal of Machine Learning Research_ , vol. 23, no. 1, pp. 2475–2483, 2022.
  * [48] Y. Li, Y. Shen, W. Zhang, Y. Chen, H. Jiang, M. Liu, J. Jiang, J. Gao, W. Wu, Z. Yang _et al._ , “Openbox: A generalized black-box optimization service,” in _Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining_, 2021, pp. 3209–3219.
  * [49] A. Pavlo, G. Angulo, J. Arulraj, H. Lin, J. Lin, L. Ma, P. Menon, T. C. Mowry, M. Perron, I. Quah _et al._ , “Self-driving database management systems.” in _CIDR_ , vol. 4, 2017, p. 1.
  * [50] S. Cereda, G. Palermo, P. Cremonesi, and S. Doni, “A collaborative filtering approach for the automatic tuning of compiler optimisations,” in _The 21st ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems_ , 2020, pp. 15–25.
  * [51] N. Schilling, M. Wistuba, and L. Schmidt-Thieme, “Scalable hyperparameter optimization with products of gaussian process experts,” in _Machine Learning and Knowledge Discovery in Databases: European Conference, ECML PKDD 2016, Riva del Garda, Italy, September 19-23, 2016, Proceedings, Part I 16_. Springer, 2016, pp. 33–48.
  * [52] M. Wistuba, N. Schilling, and L. Schmidt-Thieme, “Two-stage transfer surrogate model for automatic hyperparameter optimization,” in _Machine Learning and Knowledge Discovery in Databases: European Conference, ECML PKDD 2016, Riva del Garda, Italy, September 19-23, 2016, Proceedings, Part I 16_. Springer, 2016, pp. 199–214.
  * [53] M. Wistuba, N. Schilling, and L. Schmidt Thieme, “Scalable gaussian process-based transfer surrogates for hyperparameter optimization,” _Machine Learning_ , vol. 107, no. 1, pp. 43–78, 2018.
  * [54] M. Feurer, B. Letham, and E. Bakshy, “Scalable meta-learning for bayesian optimization using ranking-weighted gaussian process ensembles,” in _AutoML Workshop at ICML_ , vol. 7, 2018, p. 5.
  * [55] Y. Li, Y. Shen, H. Jiang, W. Zhang, Z. Yang, C. Zhang, and B. Cui, “Transbo: Hyperparameter optimization via two-phase transfer learning,” in _Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining_ , 2022, pp. 956–966.
  * [56] D. Golovin, B. Solnik, S. Moitra, G. Kochanski, J. Karro, and D. Sculley, “Google vizier: A service for black-box optimization,” in _Proceedings of the 23rd ACM SIGKDD international conference on knowledge discovery and data mining_ , 2017, pp. 1487–1495.
  * [57] S. Gelly and D. Silver, “Combining online and offline knowledge in uct,” in _Proceedings of the 24th international conference on Machine learning_ , 2007, pp. 273–280.
  * [58] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski _et al._ , “Human-level control through deep reinforcement learning,” _nature_ , vol. 518, no. 7540, pp. 529–533, 2015.
  * [59] M. P. Deisenroth, C. E. Rasmussen, and D. Fox, “Learning to control a low-cost manipulator using data-efficient reinforcement learning,” _Robotics: Science and Systems VII_ , vol. 7, pp. 57–64, 2011.
  * [60] J. Peters and S. Schaal, “Learning to control in operational space,” _The International Journal of Robotics Research_ , vol. 27, no. 2, pp. 197–212, 2008.
  * [61] X. Li, Y.-N. Chen, L. Li, J. Gao, and A. Celikyilmaz, “End-to-end task-completion neural dialogue systems,” _arXiv preprint arXiv:1703.01008_ , 2017.
  * [62] M. Johnson, M. Schuster, Q. V. Le, M. Krikun, Y. Wu, Z. Chen, N. Thorat, F. Viégas, M. Wattenberg, G. Corrado _et al._ , “Google’s multilingual neural machine translation system: Enabling zero-shot translation,” _Transactions of the Association for Computational Linguistics_ , vol. 5, pp. 339–351, 2017.
  * [63] D. Bahdanau, P. Brakel, K. Xu, A. Goyal, R. Lowe, J. Pineau, A. Courville, and Y. Bengio, “An actor-critic algorithm for sequence prediction,” _arXiv preprint arXiv:1607.07086_ , 2016.
  * [64] Y. Ling, S. A. Hasan, V. Datla, A. Qadir, K. Lee, J. Liu, and O. Farri, “Diagnostic inferencing via improving clinical concept extraction with deep reinforcement learning: A preliminary study,” in _Machine Learning for Healthcare Conference_. PMLR, 2017, pp. 271–285.
  * [65] C. Yu, J. Liu, S. Nemati, and G. Yin, “Reinforcement learning in healthcare: A survey,” _ACM Computing Surveys (CSUR)_ , vol. 55, no. 1, pp. 1–36, 2021.
  * [66] M. W. Brandt, A. Goyal, P. Santa-Clara, and J. R. Stroud, “A simulation approach to dynamic portfolio choice with an application to learning about return predictability,” _The Review of Financial Studies_ , vol. 18, no. 3, pp. 831–873, 2005.
  * [67] J. Moody and M. Saffell, “Learning to trade via direct reinforcement,” _IEEE transactions on neural Networks_ , vol. 12, no. 4, pp. 875–889, 2001.
  * [68] G. Theocharous, P. S. Thomas, and M. Ghavamzadeh, “Ad recommendation systems for life-time value optimization,” in _Proceedings of the 24th international conference on world wide web_ , 2015, pp. 1305–1310.
  * [69] B. Rolf, I. Jackson, M. Müller, S. Lang, T. Reggelin, and D. Ivanov, “A review on reinforcement learning algorithms and applications in supply chain management,” _International Journal of Production Research_ , vol. 61, no. 20, pp. 7151–7179, 2023.
  * [70] A. Haydari and Y. Yılmaz, “Deep reinforcement learning for intelligent transportation systems: A survey,” _IEEE Transactions on Intelligent Transportation Systems_ , vol. 23, no. 1, pp. 11–32, 2020.
  * [71] T. Qian, C. Shao, X. Wang, and M. Shahidehpour, “Deep reinforcement learning for ev charging navigation by coordinating smart grid and intelligent transportation system,” _IEEE transactions on smart grid_ , vol. 11, no. 2, pp. 1714–1723, 2019.
  * [72] C. J. Watkins and P. Dayan, “Q-learning,” _Machine learning_ , vol. 8, pp. 279–292, 1992.
  * [73] K. Arulkumaran, M. P. Deisenroth, M. Brundage, and A. A. Bharath, “Deep reinforcement learning: A brief survey,” _IEEE Signal Processing Magazine_ , vol. 34, no. 6, pp. 26–38, 2017.
  * [74] D. Silver, G. Lever, N. Heess, T. Degris, D. Wierstra, and M. Riedmiller, “Deterministic policy gradient algorithms,” in _International conference on machine learning_. Pmlr, 2014, pp. 387–395.
  * [75] T. P. Lillicrap, J. J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra, “Continuous control with deep reinforcement learning,” _arXiv preprint arXiv:1509.02971_ , 2015.
  * [76] M. Stonebraker and A. Pavlo, “The seats airline ticketing systems benchmark,” 2012.
  * [77] B. F. Cooper, A. Silberstein, E. Tam, R. Ramakrishnan, and R. Sears, “Benchmarking cloud serving systems with ycsb,” in _Proceedings of the 1st ACM symposium on Cloud computing_ , 2010, pp. 143–154.
  * [78] D. E. Difallah, A. Pavlo, C. Curino, and P. Cudre-Mauroux, “Oltp-bench: An extensible testbed for benchmarking relational databases,” _Proceedings of the VLDB Endowment_ , vol. 7, no. 4, pp. 277–288, 2013.
  * [79] V. Leis, A. Gubichev, A. Mirchev, P. Boncz, A. Kemper, and T. Neumann, “How good are query optimizers, really?” _Proceedings of the VLDB Endowment_ , vol. 9, no. 3, pp. 204–215, 2015.
  * [80] T. Chiba, T. Yoshimura, M. Horie, and H. Horii, “Towards selecting best combination of sql-on-hadoop systems and jvms,” in _2018 IEEE 11th International Conference on Cloud Computing (CLOUD)_. IEEE, 2018, pp. 245–252.
  * [81] T. Ivanov and M.-G. Beer, “Evaluating hive and spark sql with bigbench,” _arXiv preprint arXiv:1512.08417_ , 2015.
  * [82] Y. Ramdane, O. Boussaid, N. Kabachi, and F. Bentayeb, “Partitioning and bucketing techniques to speed up query processing in spark-sql,” in _2018 IEEE 24th international conference on parallel and distributed systems (ICPADS)_. IEEE, 2018, pp. 142–151.
  * [83] S. Huang, J. Huang, J. Dai, T. Xie, and B. Huang, “The hibench benchmark suite: Characterization of the mapreduce-based data analysis,” in _2010 IEEE 26th International conference on data engineering workshops (ICDEW 2010)_. IEEE, 2010, pp. 41–51.
  * [84] X. Zhang, Z. Chang, Y. Li, H. Wu, J. Tan, F. Li, and B. Cui, “Facilitating database tuning with hyper-parameter optimization: a comprehensive experimental evaluation,” _Proceedings of the VLDB Endowment_ , vol. 15, no. 9, pp. 1808–1821, 2022.
  * [85] X. Zhao, X. Zhou, and G. Li, “Automatic database knob tuning: A survey,” _IEEE Transactions on Knowledge and Data Engineering_ , 2023.
  * [86] M. Nomura and Y. Saito, “Efficient hyperparameter optimization under multi-source covariate shift,” in _Proceedings of the 30th ACM International Conference on Information & Knowledge Management_, 2021, pp. 1376–1385.
  * [87] Y. Liu, X. Wang, X. Xu, J. Yang, and W. Zhu, “Meta hyperparameter optimization with adversarial proxy subsets sampling,” in _Proceedings of the 30th ACM International Conference on Information & Knowledge Management_, 2021, pp. 1109–1118.
  * [88] Y. Li, Y. Shen, H. Jiang, T. Bai, W. Zhang, C. Zhang, and B. Cui, “Transfer learning based search space design for hyperparameter tuning,” in _Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining_ , 2022, pp. 967–977.
  * [89] D. Agrawal, A. El Abbadi, S. Das, and A. J. Elmore, “Database scalability, elasticity, and autonomy in the cloud,” in _International conference on database systems for advanced applications_. Springer, 2011, pp. 2–15.
  * [90] S. Loesing, M. Pilman, T. Etter, and D. Kossmann, “On the design and scalability of distributed shared-data databases,” in _Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data_ , 2015, pp. 663–676.
  * [91] N. R. Herbst, S. Kounev, and R. Reussner, “Elasticity in cloud computing: What it is, and what it is not,” in _10th international conference on autonomic computing (ICAC 13)_ , 2013, pp. 23–27.
  * [92] A. Papaioannou and K. Magoutis, “Incremental elasticity for nosql data stores,” in _2017 IEEE 36th Symposium on Reliable Distributed Systems (SRDS)_. IEEE, 2017, pp. 174–183.
  * [93] D. Seybold, S. Volpert, S. Wesner, A. Bauer, N. Herbst, and J. Domaschka, “Kaa: Evaluating elasticity of cloud-hosted dbms,” in _2019 IEEE International Conference on Cloud Computing Technology and Science (CloudCom)_. IEEE, 2019, pp. 54–61.

|  Limeng Zhang received the B.S. and M.S. and PhD degrees in computer science
from Sichuan University, China, University of Chinese Academy of Sciences,
China, and Swinburne University of Technology, Australia, respectively. She is
currently a research fellow with the Centre for Research on Engineering
Software Technologies (CREST) at the University of Adelaide, Australia. Her
research interests cover the broad area of Cloud Computing, Blockchain and
Data Mining with special emphasis on algorithm designs and performance
optimization.
---|---
|  M. Ali Babar is a Professor in the School of Computer Science, University
of Adelaide. He is a honorary visiting professor at the Software Institute,
Nanjing University, China. Prof Babar has established an interdisciplinary
research centre, CREST - Centre for Research on Engineering Software
Technologies, where he leads the research and research training of more than
30 (10 PhD students) members. He leads a theme, Platforms and Architectures
for Cybersecurity as Service, of the Cyber Security Cooperative Research
Centre (CSCRC). Prof Babar has authored/co-authored more than 220 peer-
reviewed publications through premier Software Technology journals and
conferences. In the area of Software Engineering education, Prof Babar led the
University’s effort to redevelop a Bachelor of Engineering (Software) degree
that has been accredited by the Australian Computer Society and the Engineers
Australia (ACS/EA). He coordinates both undergraduate and postgraduate
programs of Software Engineering at the University of Adelaide. Prior to
joining the University of Adelaide, he spent almost 7 years in Europe
(Ireland, Denmark, and UK) working as a senior researcher and an academic.
Before returning to Australia, he was a Reader in Software Engineering with
the Lancaster University.
---|---