Parameters are defined using a YAML manifest with the following structure:

parameters:
  - name: jvm_heap_size
    description: the size of the heap of the jvm
    unit: megabytes
    restart: false
  - name: jvm_survival_ratio
    description:  the ratio of the two survivor spaces in the JVM GC

with the following properties:

Notice that parameter definitions are shared across all the workspaces on the same Akamas installation, and require an account with administrative privileges to manage them.

Example

The following represents a set of parameters for a JVM component

parameters:
  - name: jvm_maxHeapSize
    description: Maximum heap size
    unit: megabytes
    restart: true
  - name: jvm_newRatio
    description: Ratio of old/new generation sizes
    restart: true
  - name: jvm_maxTenuringThreshold
    description: Maximum value for tenuring threshold
    restart: true
  - name: jvm_survivorRatio
    description: Ratio of eden/survivor space size
    restart: true
  - name: jvm_concurrentGCThreads
    description: Number of threads concurrent garbage collection will use
    unit: threads
    restart: true
  - name: jvm_gcType
    description: Type of the garbage collection algorithm
    restart: true

The following represents a set of CPU-related parameters for the Linux operating system

parameters:
  # CPU Related
  - name: os_cpu_sched_min_granularity_ns
    description: Target minimum scheduler period in which a single task will run
    unit: nanoseconds
    restart: false
  - name: os_cpu_sched_wakeup_granularity_ns
    unit: nanoseconds
    description: desc
    restart: false
  - name: os_cpu_sched_migration_cost_ns
    unit: nanoseconds
    description: desc
    restart: false
  - name: os_cpu_sched_child_runs_first
    description: desc
    restart: false
  - name: os_cpu_sched_latency_ns
    unit: nanoseconds
    description: desc
    restart: false
  - name: os_cpu_sched_autogroup_enabled
    description: desc
    restart: false
  - name: os_cpu_sched_nr_migrate
    description: desc
    restart: false

This section describes all the structures that can be used to define resources and objects in Akamas.

Systems are defined using a YAML manifest with the following structure:

with the following properties:

Example

The following represents a system (for Cassandra related system)

Components are defined using a YAML manifest with the following structure:

name: branin
description: The branin analytical function
componentType: function_branin
properties:
  hostname: function-server

and properties:

Examples

Example of a component for OpenJDK11:

name: JVM_1
description: The first jvm of the system
componentType: java-openjdk-11
properties:
  hostname: ycsb1.dev.akamas.io
  username: ubuntu

Example of a component for the Linux operating system:

name: os_1
description: The operating system of team 1
componentType: Ubuntu-20.04
properties:
  hostname: ycsb1.dev.akamas.io
  username: ubuntu

Metrics are defined using a YAML manifest with the following structure:

metrics:
  - name: "cpu_util"
    description: "cpu utilization"
    unit: "percent"
  - name: "mem_util"
    description: "memory utilization"
    unit: "percent"

and properties:

Supported units of measure

The supported units of measure for metrics are:

Notice that supported units of measure are automatically scaled for visualization purposes. In particular, for units of information, Akamas uses a base 2 scaling for bytes, i.e., 1 kilobyte = 1024 bytes, 1 megabyte = 1024 kilobytes, and so on. Other units of measure are only scaled up using millions or billions (e.g., 124000000 custom units become 124 Mln custom units).

Telemetry instances are defined using a YAML manifest with the following structure:

provider: Provider Name
name: My Telemetry
config:
  providerSpecificConfig1: "<value>"
  providerSpecificConfig2: 123
metrics:
- name: metric_name
  datasourceName: datsource_metric_name
  defaultValue: 1.23
  labels:
    - label1
    - label2
  staticLabels:
    staticLabel1: staticValue1
    staticLabel2: staticValue2

with the following properties for the global section

and the metrics section

A windowing policy of type stability discards temporal intervals in which a given metric is not stable, and selects, among the remaining intervals, the ones in which another target metric is maximized or minimized. Stability windowing can be sample-based or time-frame based.

The stability windowing has the following structure:

and for the comparison metric section

Example

The following fragment is an example of stability windowing (time-frame based):

type: stability
stability:
  metric: throughput
  labels:
    componentName: DB
  resolution: "30s"
  width: 10
  maxStdDev: .6
  # Comparison metric section
  when:
    metric: response_time
    labels:
      componentName: FE
    is: min

Optimization goals and constraints are defined using a YAML manifest with the following structure:

where:

Function

The function field of the Goal of a Study details the characteristics of the function Akamas should minimize or maximize to reach the desired performance objective.

The function field has the following structure:

Where:

Formula

The formula field represents the mathematical expression of the performance objective for the Study and contains variables and operators with the following characteristics:

• Valid operators are: +, -, *, /, ^, sqrt(variable), log(variable), max(variable1, variable2), and min(variable1, variable2)

• Valid variables are in the form:

  • <component_name>.<metric_name>, which correspond directly to metrics of Components of the System under test

  • <variable_name>, which should match variables specified in the variables field

Variables

The variables field contains the specification of additional variables present in the formula, variables that can offer more flexibility compared to directly specifying each metric of each Component in the formula.

Notice: each subfield of variables specifies a variable with its characteristics, the name of the subfield is the name of the variable.

The variable subfield has the following structure:

It is possible to use the notation <component_name>.<metric_name> in the metric field to automatically filter the metric’s data point by that component name is applied.

Constraints

The constraints field specifies constraints on the metrics of the system under test. For a configuration to be valid for the defined goal, such constraints must be satisfied. Constraints can be defined as absolute or relativeToBaseline.

Each constraint has the form of:

mathematical_operationcomparison_operatorvalue_to_compare

where valid mathematical operations include:

• + - * / ^

• min max

• sqrt log (log is a natural logarithm)

valid comparison operators include:

• > < <= >=

• == != (equality, inequality)

and valid values to compare include:

• absolute values (e.g, 104343)

• percentage values relative to the baseline (e.g, 20%)

As an example, you could define an absolute constraint with the following snippet:

Relative constraints can be defined by adding other constraints under the relativeToBaseline section. In the example below, for the configuration to be considered valid, it's required that the metric jvm.memory_used does not exceed by 80% the value measured in the baseline.

Aggregations

Variables used in the study formula specification and in the constraints definition can include an aggregation. The following aggregations are available: avg, min, max, sum, p90, p95, p99.

Examples

The following example refers to a study whose goal is to optimize the throughput of a Java service (jpetstore), that is to maximize the throughput (measured as elements_per_second) while keeping errors (error_rate) and latency (avg_duration, max_duration) under control (absolute values):

The following example refers to a study whose goal is to optimize the memory consumption of Docker containers in a microservices application, that is to minimize the average memory consumption of Docker containers within the application of appId="app1" by observing memory limits, also normalizing by the maximum duration of a benchmark (containers_benchmark_duration).

Optimization studies are defined using a YAML manifest with the following structure:

with the following mandatory properties:

Some of these optional properties depend on whether the study is an offline or live optimization study.

Number of trials

It is possible to perform more than one trial per experiment to validate the score of a configuration under test, e.g., to consider noisy environments.

The following fragment of the YAML definition of a study sets the number of trials to 3:

Notice: This is a global property of the study which can be overwritten for each step.

Trial aggregation

The trial aggregation policy defines how trial scores are aggregated to form experiment scores.

There are three different types of strategies to aggregate trial scores:

• AVG: the score of an experiment is the average of the scores of its trials - this is the default

• MIN: the score of an experiment is the minimum among the scores of its trials

• MAX: the score of an experiment is the maximum among the scores of its trial

The following fragment of the YAML definition of a study sets the trial aggregation to MAX:

Examples

The following system refers to an offline optimization study for a system modeling an e-commerce service, where a windowing strategy is specified:

The following offline study refers to a tuning initiative for a Cassandra-based system (ID 2)

The following offline study is for tuning another Cassandra-based system (ID 3) by acting only on JVM and Linux parameters

The MetricSelection field in a study specifies the metrics of the system. Such selection has only the purpose to specify which metrics need to be tracked while running the study and does not affect the optimization.

In case this selection is not specified, all metrics are considered.

A metrics selection can either assume the value of all to indicate that all the available metrics of the system of the study should be tracked, or can assume the value of a list of the names of metrics of the system that should be tracked prepended with the name of the component.

Example

The following fragment is an example:

metricsSelection:
  - application.response_time
  - application.error_rate
  - jvm1.gc_time

The Windowing field in a study specifies the windowing policy to be adopted to score the experiments of an optimization study.

The two available windowing strategies have different structures:

• Trim windowing: trim the temporal interval of a trial, both from the start and the end of a specified temporal amount - this is the default strategy

• Stability windowing: discard temporal intervals in which a given metric is not stable and selects the temporal interval in which a metric is maximized or minimized.

In case the windowing strategy is not specified, the entire time window is considered.

The ParameterSelection field in a study specifies which parameters of the system should be tuned while running the optimization study.

In case this selection is not specified, all parameters are considered.

A parameter selection can either assume the value of all to indicate that all the available parameters of the system of the study should be tuned, or can assume the value of a list with items of the shape like the one below:

Notice that, by default, every parameter specified in the parameters selection of a study is applied. This can be modified, by leveraging the Parameter rendering options.

Example

The following fragment is an example:

parametersSelection:
  - name: jvm.jvm_gcType
  - name: jvm.jvm_maxG1NewSizePercent
    domain: [10, 90]
  - name: webserver.aws_ec2_instance_size
    categories: ["large", "x.large", "2x.large"]

A windowing policy of type trim trims the temporal interval of a trial, both from the start and from the end of a specified temporal amount (e.g., 3 seconds).

The trim windowing has the following structure:

In case a windowing policy is not specified, the default windowing corresponding to trim[0s,0s] is considered.

Example

The following fragment shows a windowing strategy of type "trim" where the time window is specified to start 10s after the beginning of the trial and to end immediately before the end of the trial:

windowing: # the temporal window in which to compute the score of a trial
  type: "trim" # type of windowing is trim
  trim: [10s, 0s]

The kpis field in a study specifies which metrics should be considered as KPI for an offline optimization study.

In case this selection is not specified, all metrics mentioned in the goal and constraint of the optimization study are considered.

A KPI is defined as follows:

Notice that the textual badge displayed in the Akamas UI use "Best name".

Example

The following fragment is an example of a list of KPIs:

kpis:
  - name: "Response time"
    formula: renaissance.response_time
    direction: minimize
  - name: "CPU used"
    formula: renaissance.cpu_used
    direction: minimize
  - name: "Memory used"
    formula: renaissance.mem_used
    direction: minimize

Telemetry Providers are defined using a YAML manifest with the following structure:

with the following properties:

Refer to the page which describes the out-of-the-box Telemetry Providers that are created automatically at Akamas install time.

A baseline step performs an experiment (a baseline experiment) and marks it as the initial experiment of a study. The purpose of the step is to build a reference configuration that Akamas can use to measure the effectiveness of an optimization conducted towards a system.

When a bootstrap step imports an experiment from another study, the step copies not only the experiment but also its trials and the system metrics generated during its execution.

The bootstrap step has the following structure:

where the from field should have the following structure:

with:

• study contains the name or ID of the study from which to import experiments

• experiments contains the numbers of the experiments from which to import

Examples

The following is an example of a bootstrap step that imports four experiments from two studies:

You can also import all the experiments of a study by omitting the experiments field:

The renderParameters and doNotRenderParameters can be used to specify which configuration parameters should be rendered when doing experiments within a step.

Parameter rendering can be defined at the step level for baseline, preset, and optimize steps. This is not possible for bootstrap steps as bootstrapped experiments are not executed.

Examples

The following baseline step specifies that every parameter of the component 'os' should not be rendered while the parameter 'cpu_limit' of the component 'docker' should be rendered:

The following preset step specifies that the parameter 'cpu_limit' of the component 'docker' should be rendered:

The following optimize step specifies that every parameter of the component 'os' should not be rendered:

The workloadsSelection is a structure used to define the metrics that are used by Akamas to model workloads as part of a live optimization study.

with the following fields:

Workload metrics must have been defined in the metricsSelection. Variables used in the name field can include an aggregation. The following aggregations are available: avg, min, max, sum, p90, p95, p99.

Examples

The following refers to a workload represented by the metric transactions_throughput of the konakart component with multiple aggregations:

Component types are defined using a YAML manifest with the following structure:

and properties for the general section:

The parameter section describes the relationship between the component type and already defined parameters with the following properties:

The metric section describes the relationship between the component type and already defined metrics with the following properties:

Notice that component type definitions are shared across all the workspaces on the same Akamas installation, and require an account with administrative privileges to manage them.

Examples

Example of a component for the Cassandra component type:

Example of a component for the Linux operating component type:

A baseline step performs an experiment (a baseline experiment) and marks it as the initial experiment of a study. The purpose of the step is to build a reference configuration that Akamas can use to measure the effectiveness of an optimization conducted towards a system.

A baseline step offers three options when it comes to selecting the configuration of the baseline experiment:

• Use a configuration made with the default values of the parameters taken from the system of the study

• Use a configuration taken from an experiment of another study

• Use a custom configuration

The baseline step has the following structure:

where the from field should have the following structure:

with

• study contains the name or ID of the study from which to take the configuration

• experiments contains the number of the experiment from which to take the configuration

Examples

Baseline configuration with default values

Default values for the baseline configuration only require setting the name and type fields:

Baseline configuration from another study

The configuration taken from another study to be used as a baseline only requires setting the from field:

Notice: the from and experiments fields are defined as an array, but can only contain one element.

Custom baseline configuration

The custom configuration for the baseline only requires setting the values field:

The Optimizer Options is a set of parameters used to fine-tune the study optimization strategy during the optimize step.

Optimizer options have the following structure:

Options for both online and offline studies

Safety Factor

The safetyFactor field specifies how much the optimizer should stay on the safe side in evaluating a candidate configuration with respect to the goal constraints. A higher safety factor corresponds to a safer configuration, that is a configuration that is less likely to violate goal constraints.

Acceptable values are all the real values ranging between 0 and 1, with (safetyFactor - 0.5) representing the allowed margin for staying within the defined constraint:

• 0 means "no safety", as with this value the optimizer totally ignores goal constraint violations;

• 0.5 means "safe, but no margin", as with this value the optimizer only tries configurations that do not violate the goal constraints, by remaining as close as possible to them;

• 1 means "super safe", as with this value the optimize only tries configurations that are very far from goal constraints.

For live optimization studies, 0.6 is the default value, while for offline optimization studies, the default value is 0.5.

Options for offline studies

Options for live studies

For live optimization studies, the optimizerOptions field can be used to specify several important parameters governing the live optimization:

Online Mode

The onlineMode field specifies how the Akamas optimizer should operate:

• RECOMMEND: configurations are recommended to the user by Akamas and are only applied after having been approved (and possibly modified) by the user;

• FULLY AUTONOMOUS MODE: configurations are immediately applied by Akamas.

Safety Mode

The safetyMode field describes how the Akamas optimizer should evaluate the goal constraints on a candidate configuration for that configuration to be considered valid:

• GLOBAL: the constraints must be satisfied by the configuration under all observed workloads in the configuration history - this is the value taken in case onlineMode is set to RECOMMEND;

• LOCAL: the constraints are evaluated only under the workload selected according to the workload strategy - this should be used with onlineMode set to FULLY_AUTONOMOUS.

Notice that when setting the safetyMode to LOCAL, the recommended configuration is only expected to be good for the specific workload selected under the defined workload strategy, but it might violate constraints under another workload.

Workload Strategy

The workloadOptimizedForStrategy field specifies the workload strategy that drives how Akamas leverages the workload information when looking for the next configuration:

• MAXIMIN: the optimizer looks for a configuration that maximizes the minimum improvements for all the already observed workloads;

• MOST_VIOLATED: for each workload, the workload of the configuration with more violations is considered.

Exploration Factor

The explorationFactor field specifies how much the optimizer explores the (unknown) optimization space when looking for new configurations. For any parameter, this factor measures the difference between already tried values and the value of a new possible configuration. A higher exploration factor corresponds to a broader exploration of never-tried-before parameter values.

Acceptable values are all the real values ranging between 0 and 1, plus the special string FULL_EXPLORATION:

• 0 means "no exploration", as with this value the optimizer chooses a value among the previously seen values for each parameter;

• 1 means "full exploration, except for categories", as with this value the optimizer for a non-categorical parameter any value among all its domain values can be chosen, while only values (categories) that have already been seen in previous configurations are chosen for a categorical parameter;

• FULL_EXPLORATION means "full exploration, including categories" as with this value the optimizer chooses any value among all its domain values, including categories, even if not already seen in previous configurations.

Example

The following fragment refers to an optimization study that runs 100 experiments using the SOBOL optimizer and forces 50% of the experiments to use the beta-warping option, enabling a more sophisticated but longer optimization: