Overview¶
The below describes the required steps to get started with using Concertio Optimizer Studio software.
While Optimizer Studio can run under any modern Linux distribution, the directions below have been tested on Ubuntu 18.04, Ubuntu 16.04, CentOS 6 and CentOS 7.
Activating Your License¶
Prior to using the Optimizer Studio, you'll have to activate your license. In order to do so you'll need to use the optimizer-studio-license tool:
$ optimizer-studio-license
Concertio Optimizer Studio License Handling Tool
Online documentation is available at https://www.concertio.com/docs/
Usage: optimizer-studio-license ACTION [--verbose]
Required one of the following ACTIONs:
--activate=PROD_KEY Online Activation of your installation using the product key [PROD_KEY].
--deactivate Online Deactivation of your installation.
--activation-request=PROD_KEY Generate an offline activation request file named <activation.req> using
the product key [PROD_KEY].
--activation-by-file=FILE_PATH Offline activation using the activation response file [FILE_PATH].
--deactivation-request Generate an offline deactivation request file <deactivation.req>.
--show Display license information.
--help Print this help message.
Optional:
--verbose Detailed output.
If your system is connected to the internet you can use the online activation:
$ optimizer-studio-license --activate=XXXXXX-XXXXXX-XXXXXX-XXXXXX-XXXXXX-XXXXXX
(XXXXXX-XXXXXX-XXXXXX-XXXXXX-XXXXXX-XXXXXX is the license key you received when you purchased the Optimizer Studio).
Otherwise, if your system is offline the procedure is as follows-
First you'll need to generate a request file:
$ optimizer-studio-license --activation-request=XXXXXX-XXXXXX-XXXXXX-XXXXXX-XXXXXX-XXXXXX
This will generate a request file named activation.req, you should copy this file and send it as attachment by email to Concertio (support@concertio.com).
Next, in a reply email you'll receive an activation file. You should copy the file to your system and execute the command:
$ optimizer-studio-license --activation-by-file=FILE_PATH
(FILE_PATH is the file path of the activation file).
Deactivation¶
In case you wish to deactivate your license (for example, if you wish to use your license on a different system), you should use the following command (if your system is online):
$ optimizer-studio-license --deactivate
Alternatively, if your system is offline, you should use:
$ optimizer-studio-license deactivation-request
This will generate a deactivation request file named deactivation.req. You should email this file to Concertio.
Using Optimizer Studio¶
For a brief description of available command line parameters, issue:
$ optimizer-studio --help
Concertio Optimizer Studio, version 2.5.0 (build time: Dec 26 2019, 12:00:00)
AI-Powered performance optimization tools
License expiration date: January 1, 2021
Online documentation is available at https://www.concertio.com/docs/
Usage: optimizer-studio [OPTION] [OPTION] ... <workload> [workload args]
optimizer-studio [OPTION] [OPTION] ...
Default workload path: ./workload.sh
Command line options:
--sampling-mode=MODE Select sampling mode. MODE may be either [sync], async:
sync - sampling is synchronized with workload execution
async - periodic sampling with constant intervals
--settings=PATH Path to settings YAML file. By default settings.yaml
--knobs=PATH Path to configuration YAML files. When no configuration file(s)
have been provided, then ./knobs.yaml is used. If no such file exists,
the embedded knobs are used.
Each file specified on a command line may override
settings defined in a previous configuration file
--knobs=embedded Load embedded configuration file, even though other configuration file(s)
has been specified
--retain Retain optimization data from previous Optimizer Studio run
--replay=<metrics.csv file>
Feed all metrics from the specified CSV file produced by a previous
optimizer run back to the optimizer, then proceed with optimization
--workload-timeout=N Maximum time allowed for a single workload run, after which it is killed
The format for N: AhBmCs, for hours, minutes and seconds
--max-minutes=N Maximum optimization time. If not specified, the optimization process
ends according to internal logic
--workload=<PARAMS> This parameter causes the Optimizer Studio to run in parallel mode. The
PARAMS specify workload starter name and parameters for parallel execution.
The parameters can be different for each starter script
--http-port=PORT The port number to use for REST HTTP server if Optimizer Studio runs in
REST server mode
--testknob=KNOB-NAME Run testing procedure for a knob identified by KNOB-NAME and exit
--testknob=all Run testing procedure for all knobs and exit
--testknob=none Skip mandatory knob testing procedure
--settings-script=PATH The name of generated script that applies the optimal settings discovered
throughout the run. If not specified, the name is defined automatically
--report=status Output a status report of already running Optimizer Studio session. Should
be run from another terminal session
--session=SESSIONID Provide your own Optimizer Studio session ID.
For example, in case there are several sessions running
simultaneously which require some automation logic.
If not specified, a random SESSIONID is generated automatically
and printed out on the terminal at the beginning
--refine-only Calculate optimal knob configuration for the previous Optimizer-Studio
run.
--no-refine Disable optimal knob settings postprocessing.
--help Display this help message
Running Optimizer Studio¶
In order to optimize a workload, provide a workload script as a parameter, as follows:
$ sudo optimizer-studio ./my_workload
Concertio Optimizer Studio version 2.4.0
Optimizing ./my_workload
Optimization target: duration
Starting runtime (no time limit) ...
...
Optimization time: 00:06:23
Progress: 100%
Best known knob settings so far:
vm.swappiness: 60
sys.vm.overcommit_ratio: 40
Settings written to: optimizer_studio_settings.sh
Alternatively, if your have a workload.sh file in the current directory, you could run optimizer-studio without any argument and optimizer will look for that file automatically.
In this example, the script my_workload is optimized by Optimizer Studio. Since no configuration file is specified using --knobs=, Optimizer Studio defaults to optimizing CPU and OS knobs, unless you already have a predefined knobs.yaml in current folder. Optimizing CPU and OS knobs requires root access, so this is why Optimizer Studio is executed using sudo in the above example.
There are two main ways to use Optimizer Studio to optimize a workload:
- Synchronous Sampling (Optimizing Full Workloads) - This is the default optimization mode. Optimizer Studio will run the workload until completion several times and will attempt to minimize its runtime or maximize its reported metric using different system settings. This method is appropriate for complex workloads.
- Asynchronous Sampling (Optimizing Specific Metrics) - By specifying
--sampling-mode=async, Optimizer Studio will identify phases of execution of a workload and explore the best settings for each phase. This method is appropriate for simpler or synthetic workloads, where early feedback of application performance can be used to run many more experiments.
The specifics of the optimization method can be controlled using the configuration files.
Workload Settings¶
Optimizer Studio is responsible for running the workload provided by workload script. There are several command line parameters that control the way Optimizer Studio runs the workload:
--max-minutes. The maximum optimization time can be limited by this parameter. If it's not specified or is zero, Optimizer Studio will terminate the optimization process according to its estimations.
--settings-script. After optimization, Optimizer Studio outputs the discovered optimal settings and the baseline settings to this file, which can run as a script.
Running workloads as a non-root user while optimizing OS/CPU knobs¶
Optimizer Studio requires root access when optimizing OS and CPU knobs. It is possible to run the workload as the current user using su as in the following example:
$ sudo optimizer-studio su - $USER -c "./workload.sh"
Running Long Workloads¶
Status Report¶
During optimization session, Optimizer Studio prints out a short line about its progress. If a user wants to get more detailed information about optimization session status, they can open another terminal session and run the following command:
$ optimizer-studio --report=status
In case that more than one optimization session run at the same time on the same computer, an additional --session command line parameter can be used:
$ optimizer-studio --report=status --session=<SESSION_ID>
where the session ID value is output to the terminal at the beginning of the optimizer session
Workload Timeout¶
Sometimes, a workload script can run too long time or even indefinitely. In such cases a user might want to limit a single workload run time with the --workload-timeout command parameter. In case that workload script runs more than the allowed time, Optimizer studio will kill it using SIGKILL signal, and the corresponding knob settings will be invalidated.
The format for time specification is AhBmCs where A, B, C specify correspondingly hours, minutes and seconds. For example:
$ optimizer-studio --knobs=<my_knobs.yaml> --workload-timeout=5m ./my_workload.sh
Configuring Knobs¶
Optimizer Studio can optimize user-defined knobs by providing a configuration file. This is explained in the Configuration section.
Resuming Stopped Optimization Session¶
Sometimes, when optimization session stops in the middle, a user may want to resume it from the same point it's stopped. Retaining Optimization Data is one way to achieve this. Another way is to "replay" the data collected during the previous optimization session.
Retaining Optimization Data¶
Optimizer Studio stores the optimization data in ${HOME}/.concertio/opt.data. By default, upon invocation of Optimizer Studio, this file is removed. In order to retain the data from the previous run, the --retain command line parameter can be used:
$ optimizer-studio --retain ./my_workload
Replaying Optimization Samples¶
During the optimization, Optimizer Studio stores all metrics collected for each knob configuration applied in a CSV file. This file is stored in ${HOME}/.concertio directory and has the name metrics_<timestamp>.csv, where timestamp specifies the file creation time at the beginning of optimization session. Using the --replay command line parameter, a user can feed all this data to the optimizer:
$ optimizer-studio --knobs=<my_knobs.yaml> --replay=${HOME}/.concertio/<my_metrics>.csv ./my_workload.sh
When To Use Retain And Replay¶
Each method of resuming optimization has its pros and cons.
Retaining Optimization Data allows to restore the optimization session exactly in the same state as it was when the optimization has stopped. However, if there were any changes in the environment, knobs definitions or product version, Optimizer Studio may fail to read this information, and then it discards it altogether. In this case the optimization starts from the very beginning.
In addition, the opt.data file is overwritten each time the Optimizer Studio runs. So if users do not want the file to be lost, they need to backup it.
Replaying metrics.csv uses the data in this file. Prior to invoking the Optimizer Studio, users can review it, modify, drop some invalid samples, etc. Replaying the CSV file is a fast operation. However the optimizer state after replay is not a precise copy of its state prior to optimization stop. Following this, the optimizer may decide to reevaluate some knob configurations, which may take additional time to run the workload. However, this overhead is usually relatively small.
Optimal Knob Settings Postprocessing¶
By default, the Optimizer Studio starts a refining stage after the completion of the optimization stage. This refining stage tries to minimize the number of knobs which are not configured to their baseline configuration.
If you wish to skip this refinement stage, you can use the --no-refine option. For example:
$ optimizer-studio --knobs=<my_knobs.yaml> ./my_workload.sh --no-refine
If you stopped your job using ctrl-c, you can refine the best knob configuration (as achieved by the stopped job) by using the --refine-only argument. Running the Optimizer Studio with this argument will resume your previous job, but will skip directly to the configuration refinement stage.
Example:
$ optimizer-studio --knobs=<my_knobs.yaml> ./my_workload.sh --refine-only
Using Optimization Results¶
Optimizer studio stores the results of the optimization in a script, as configured in settings.yaml. This script can be used to apply the discovered results:
$ /tmp/studio-settings.XYZ.sh tuned
Concertio Optimizer Studio, version 2.4.0
Auxiliary script for loading optimized settings for ./my_workload
Creation date: Thu Dec 12 13:35:58 UTC 2019
Apply tuned settings
...
To revert to baseline, use:
$ /tmp/studio-settings.XYZ.sh baseline
Concertio Optimizer Studio, version 2.4.0
Auxiliary script for loading optimized settings for ./my_workload
Creation date: Thu Dec 12 13:35:58 UTC 2019
Applying baseline settings
...
To define bash variable array with the knob values, use:
$ . /tmp/studio-settings.XYZ.sh valarray
Concertio Optimizer Studio, version 2.4.0
Auxiliary script for loading optimized settings for ./my_workload
Creation date: Thu Dec 12 13:35:58 UTC 2019
Exporting values as KNOB_VALUES_TUNED and KNOB_VALUES_BASELINE array variables
$ echo ${KNOB_VALUES_TUNED[@]}
...