Language Support for Adaptation: Intent-Driven Programming in FAST

TL;DR

This paper proposes an intent-driven programming model that allows programs to adapt dynamically based on specified intents, enhancing flexibility and resource management, demonstrated through the FAST language extension of Swift.

Contribution

It introduces FAST, a novel intent-driven programming language that extends Swift, enabling dynamic adaptation to environmental changes and user-defined intents during execution.

Findings

FAST supports dynamic adaptation to environment changes.

FAST enables mixing procedural control with feedback-based control.

FAST demonstrates improved resource management and flexibility.

Abstract

Historically, programming language semantics has focused on assigning a precise mathematical meaning to programs. That meaning is a function from the program's input domain to its output domain determined solely by its syntactic structure. Such a semantics, fosters the development of portable applications which are oblivious to the performance characteristics and limitations (such as a maximum memory footprint) of particular hardware and software platforms. This paper introduces the idea of intent-driven programming where the meaning of a program additionally depends on an accompanying intent specification expressing how the ordinary program meaning is dynamically modified during execution to satisfy additional properties expressed by the intent. These include both intensional properties---e.g., resource usage---and extensional properties---e.g., accuracy of the computed answer. To demonstrate the intent-driven programming model's value, this paper presents a general-purpose intent-driven programming language---called FAST---implemented as an extension of Swift. FAST consists of an intent compiler, a profiler, a general controller interface and a runtime module which supports interoperation with legacy C/C++ codes. Compared to existing frameworks for adaptive computing, \FAST{} supports dynamic adaptation to changes both in the operating environment and in the intent itself, and enables the mixing of procedural control and control based on feedback and optimization.

Figures

Tables

Table 1. Table 1 . Comparison between different autotuning systems.

	PetaBricks	Green	EnerCaml	OpenTuner	PowerDial	FAST
User-defined intents	●	◐	◐	●	●	●
Programming language integration	●	○	●	○	○	●
Dynamic change to intent	○	○	○	○	◐	●
Dynamic change to configuration space	○	○	○	○	○	●
Non-uniform configuration space	○	○	○	●	○	●
Integrated dynamic control	○	●	○	○	●	●
General controller and/or optimizer concept	○	○	○	●	●	●
Energy-aware	○	●	●	●	●	●

Table 2. Table 2 . Main concepts of the programming model.

	Knob	Measure	Intent
Library API	Exposes its value to the application	Exposes its value to the runtime	Defines its   scope
Intent specification	Defines its range	Declares it	Defines it
Runtime	Controls its value	Observes its value	Attempts to satisfy it

Table 3. Table 3 . Application-Agnostic Test Suite for FAST

#	Example	Expected
		Verdict
1	Change from low to high constraint goal (and vice versa) with enough time to meet the intent.	PASS
2	Change between constraint measures, e.g. from latency to performance (defined as 1/latency), while minimizing energy.	PASS
3	Change the optimization type from min to max while negating the objective function during the course of an execution. Should have no effect on the behavior of the system.	PASS
4	Negate the objective function should result in a change in the corresponding measure values.	PASS
5	Change from low to high constraint goal (and vice versa) without enough time to meet the intent.	FAIL
6	Use a constraint goal that is not achievable (no configuration achieves a constraint measure that is high/low enough).	INVALID

Table 4. Table 4 . Overview of applications used in experimental evaluation.

App.	Knobs	Constraint	Opt. Type and	Source Lines of Code
		Measure	Obj. Function	Base	Wrapper	FAST
X264	Motion Estimation Range, Sub-Pixel Refinement, Number of Reference Frames, Quantization Step	performance	max quality	105992	296	58
SAR	Coarse Decimation Ratio, Fine Decimation Ratio, Number of Ranges, Number of Beams	performance	max quality	543	–	41
Jacobi	Iterations Between Synchronization	performance	min power	165	–	6

Table 5. Table 5 . Summary of Application Executions Comparing FAST to Oracles A and B

Statistic	x264			SAR			Jacobi
	FAST	Or. A	Or. B	FAST	Or. A	Or. B	FAST	Or. A	Or. B
MAPE	0.032	0.941	0.025	0.027	0.667	0.036	0.008	1.678	0.085
Mean Obj. Function	6.18e4	3.80e4	3.60e4	1.10	0.53	0.96	3.42e6	3.46e6	3.39e6

Table 6. Table 6 . Application and Platform Configuration Knob Kind and Trade-offs

Module	Knob	Kind	Key Measure Trade-Off
System	Utilized Cores	Ordinal	latency $⇅$ energy
	Utilized Core Frequency	Ordinal	latency $⇅$ energy
X264	Motion Estimation Range	Ordinal	latency $⇅$ bitrate
	Sub–Pixel Refinement	Categorical	latency $⇅$ bitrate
	Number of Reference Frames	Ordinal	latency $⇅$ bitrate
	Quantization Step	Ordinal	latency $⇅$ quality
SAR	Coarse Decimation Ratio	Ordinal	latency $⇅$ quality
	Fine Decimation Ratio	Ordinal	latency $⇅$ quality
	Number of Ranges	Ordinal	latency $⇅$ quality
	Number of Beams	Ordinal	latency $⇅$ quality
Jacobi	Iterations Between Synch.	Ordinal	latency $⇅$ powerConsumption

Equations

$$\textup{opt}(f(m_{0},\ldots,m_{n}))\textup{ such that }\left\{\begin{array}[]{l}m_{c}=g\\ \forall k\in K.~{}v_{k}\in D_{k}\end{array}\right.$$

$$\begin{array}[]{@{}c@{\hspace{2mm}}c@{\hspace{2mm}}l@{\hspace{2.5mm}}c@{\hspace{2.5mm}}l@{}}s\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{Spec}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\texttt{intent }n\texttt{ }o\texttt{(}e\texttt{)}\texttt{ }[\texttt{ such that }m\texttt{ == }c\texttt{ }]\\ \hfil\hskip 5.69054pt&\hfil\hskip 5.69054pt&\hfil\hskip 7.11317pt&\hfil\hskip 7.11317pt&\texttt{measures }\{\texttt{ }m_{i}:t_{i}\texttt{ }\}^{1\leq i\leq|M_{s}|}\\ \hfil\hskip 5.69054pt&\hfil\hskip 5.69054pt&\hfil\hskip 7.11317pt&\hfil\hskip 7.11317pt&\texttt{knobs }\{\texttt{ }k_{i}\texttt{ = }e_{i}\texttt{ }[\texttt{ reference }c_{i}\texttt{ }]\texttt{ }\}^{1\leq i\leq|K_{s}|}\texttt{ }[\texttt{ such that }e\texttt{ }]\\ o\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{Opt}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\texttt{min}\,|\,\texttt{max}\\ e\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{Expr}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&c\,|\,m\,|\,f\langle e_{i}\rangle^{1\leq i\leq|f|}\\ c\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{C}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\textit{constants}\\ n\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{N}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\textit{intent names}\\ t\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{T}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\textit{type names}\\ m\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{M}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\textit{measure names}\\ k\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{K}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\textit{knob names}\\ f\hfil\hskip 5.69054pt&\in\hfil\hskip 5.69054pt&\textsf{F}\hfil\hskip 7.11317pt&::=\hfil\hskip 7.11317pt&\textit{function names}\end{array}$$

$$C[e^n;M,r,d^n]\le nC[e;M,r,d],$$

$$C_L[e;M,r,d]=\underset{n\to \infty }{\mathrm{liminf}}\frac{C[e^n;M,r,d^n]}{n}\le C[e;M,r,d],$$

$$\underset{\mathbf{k},{\mathbf{k}}^{\prime }}{\min }$$

$$\underset{N\to \infty }{\lim }\sum _{i=1}^N\frac{1}{N}C[e_{k_i};M_{k_i^{\prime }},r_l,d]⪯{\mathbf{R}}_l,\forall l,$$

$$\underset{\mathbf{w}}{\min }$$

$$A\mathbf{w}⪯\mathbf{R},$$

$$\sum _{(k,k^{\prime })\in K}{w}_{k,k^{\prime }}=1,$$

$$w_{k,k^{\prime }}⪰0.$$

$$\begin{array}[]{cl}&\lim_{N\rightarrow\infty}\sum_{i=1}^{N}{\frac{1}{N}C[e_{k^{*}_{i}};M_{k^{\prime*}_{i}},o,d]}\\ \leq&\lim_{N\rightarrow\infty}\sum_{i=1}^{N}{\frac{1}{N}C[e_{k^{**}};M_{k^{\prime**}},o,d]}\\ =&C[e_{k^{**}};M,o,d],\end{array}$$

$$\underset{k}{\min }$$

$$C[e_k;M_{k^{\prime }},r_l,d]⪯{\mathbf{R}}_l,\forall l.$$

Full text

To demonstrate the intent-driven programming model’s value, this paper presents a general-purpose intent-driven programming language—called FAST—implemented as an extension of Swift. FAST consists of an intent compiler, a profiler, a general controller interface and a runtime module which supports interoperation with legacy C/C++ codes. Compared to existing frameworks for adaptive computing, FAST supports dynamic adaptation to changes both in the operating environment and in the intent itself, and enables the mixing of procedural control and control based on feedback and optimization.

1. Introduction

Recent proposals allow developers to create self-adaptive applications (Oreizy et al., 1999, Kephart and Chess, 2003) while abstracting platform-specific monitoring and resource allocation logic (Sampson et al., 2011, Imes and Hoffmann, 2016, Taylor et al., 2017, Mishra et al., 2018). These systems provide a portable approach to constructing adaptive applications, but they are rigid with respect to the kind of adaptation they support and the way that the desired behavior is specified. Much of the recent research targets adaptation to meet energy constraints. While approaches exist that support re-targeting adaptation to meet latency constraints (Imes and Hoffmann, 2016, Taylor et al., 2017, Mishra et al., 2018), these frameworks lack a general-purpose mechanism (a language) for communicating and directly manipulating—in the program—that adaptive capability. Existing language-level support for adaptation (Salvaneschi et al., 2013) focuses on different mechanisms for introducing variability in programs, and on composing adaptive components. To the best of our knowledge, no existing system makes both the goal and means of adaptation general, first-class members of a programming language.

Therefore, we propose a novel intent-driven programming model that extends traditional general-purpose programming languages with new syntax to express intents and a library API for identifying, monitoring, and manipulating the program’s adaptive aspects. An intent (1) expresses the goal of adaptation as a constrained optimization problem, (2) identifies variables (knobs) in the application code or platform configuration that can be modified to achieve the goal, and (3) identifies values (measures) in the application and hardware platform as elements of the objective function and constraint. An intent-driven program executes on top of a runtime that uses the intent to compute a schedule of knob settings that meets the optimization constraint while providing optimal behavior with respect to the objective function. In contrast to existing systems, the intent is general and dynamic—for example, intents may comprise arbitrary arithmetic expressions over the measures—and may change dynamically. The space of configurations that is available for adaptation can be changed dynamically from within the program, supporting use cases that require mixing procedural control with the automatic adaptation provided by FAST using feedback and optimization. This paper contributes:

• •

A precise definition of the intent-driven programming model, which enables the portable development of adaptive applications, by letting users express intents alongside their application code, which guide the dynamic reconfiguration of the system.

• •

A description of the FAST architecture, an instance of the intent-driven programming model built on top of the Swift programming language. FAST generalizes several types of existing frameworks for building adaptive systems, by supporting flexible intents written in terms of both application measures and platform measures, requiring adaptation in both application configuration and platform configuration.

• •

An experimental evaluation of the FAST system on three example applications, executed on an embedded system. The evaluation demonstrates the ability to adapt dynamically to changes in operating conditions and in intent, including dynamic, programmatic manipulation of the configuration space. Benefits of this capability in FAST compared to two other tools (PowerDial and OpenTuner) from the autotuning domain are also highlighted in the evaluation.

2. Background and Related Work

Although no existing system with first-class language support for expressing intents is general enough to express the iterative, dynamically adaptive applications for which FAST is designed, elements of the FAST architecture can be found across a number of different domains. This section reviews the main related works, and discusses how they relate to FAST. Table 1 compares FAST to several systems from the autotuning domain (Section 2.2), where the closest related work can be found.

2.1. Approximate computing

Approximate computing comprises various techniques to trade off the quality of a computation’s results for some other aspect of the computation, such as performance, latency or energy efficiency. The generality of the FAST architecture in part stems from delegating the definition of application-specific notions such as quality to the programmer. In a FAST application, quality is just a measure, and requires no distinguished treatment by the runtime. Thus, FAST is flexible enough to constitute a general framework for expressing and automatically choosing among these different design choices. For example, loop perforation (Sidiroglou-Douskos et al., 2011) can be implemented in FAST by making the loop stride an application knob. General surveys of this field were given by Han and Orshansky (2013), Xu et al. (2016), Mittal (2016). The PowerDial system constructs knobs at compile-time and dynamically adjusts their settings at runtime to maintain a user-specified goal (Hoffmann et al., 2011). JouleGuard coordinates application-level adaptation (like that done with PowerDial) with system-level resource management to meet energy guarantees (Hoffmann, 2015). While similar to FAST, PowerDial and JouleGuard are much less flexible as they do not provide users with a way to manipulate the knobs once the program is running. In contrast, FAST programmers can dynamically change goals (Section 4.2) and available knobs (Sections 4.1.1 and  6.3.1) without stopping and recompiling.

2.2. Autotuning Systems and Languages

PetaBricks (Ansel et al., 2009) allows users to provide different algorithmic choices, from which an autotuner finds an optimal combination. Its main purpose is to optimize the time efficiency of code automatically. Compared to FAST, it does not have a general notion of a measure and makes choices at compile time. Unlike PetaBricks, FAST automatically adapts to dynamic events while allowing programmers to programmatically change intent and available configuration space.

Green (Baek and Chilimbi, 2010) does support programs that recalibrate themselves during execution. It provides two kinds of constructs: loop approximation and function approximation. Green also provides a statistical guarantee for the resulting quality of service. However, Green assumes a monotonic relationship between quality degradation and energy efficiency, and this information may not be readily available to a user. Unlike FAST, Green does not have a general notion of knob and its controller is hard-wired.

EnerCaml (Ringenburg et al., 2014) extends OCaml with an approximation annotation system, a profiling system and an autotuner. The annotation system allows users to provide approximate versions for every expression. The profiling system calculates a single user-specified quality of a function’s result (which corresponds to a FAST measure). In contrast to the general measure monitoring facilities of FAST, EnerCaml estimates energy savings by calculating the ratio of approximated operations to approximable ones. The autotuner calculates the Pareto frontier to see the trade-off between the estimated energy consumption and the quality of the result. EnerCaml is the first language designed to explore the trade-off between different approximation strategies. However, its concept of autotuning is restrictive, focusing only on energy savings, and does not have a general notion of measure. Further, it is designed for exploring different configurations at the prototyping stage and, unlike FAST, does not allow the system to adapt to environmental changes that occur during execution.

To the best of our knowledge, OpenTuner (Ansel et al., 2014) is the only currently available autotuning framework with a general notion of measure and search technique. It lets the user define both constrained and unconstrained objectives. OpenTuner allows users to explore the online behaviour of previously unexplored configurations. However, OpenTuner does not take into account the possible error between run time and compile time performance. Therefore, the control of iterative (e.g. streaming) applications cannot be accommodated with OpenTuner in a straightforward manner.

2.3. Hyperparameter Optimization

Hyperparameter optimization is a two-level framework that tunes hyperparameters of a learning algorithm, to achieve better performance. Many standard optimization heuristics, such as simulated annealing and genetic algorithms, could be employed for this purpose. Currently, Optunity (Claesen et al., 2014) is the only general library which supports hyperparameter tuning. FAST similarly includes a unconstrained global optimization module which can be straightforwardly extended to support common hyperparameter optimization heuristics. For constrained optimization, Capri (Biswas et al., 2017) offers a general approach to find optimal hyperparameters of a program with input features taken into account.

3. Intent-Driven Programming

Adaptive software changes its behavior to meet a goal (intent) despite changes in external operating conditions. To do so, the software must detect that the current behavior deviates from the intent, determine the action necessary to recover that behavior, and implement that action. In the intent-driven programming model, these capabilities are enabled by:

• •

a library API that lets the system control the application state (application knobs), with feedback (measures) to guide the controller, and delineate the scope where measures should be recorded (optimize);

• •

an intent specification that declares the knobs and measures that should be considered by the system, defines permissible assignments (ranges) for these knobs, and defines the goal of adaptation, in the form of a constrained optimization problem: to minimize or maximize an objective function, subject to a constraint;

• •

a runtime that monitors the state of the application and platform as seen through the measures, computes the schedule of configurations needed to achieve the intent, and reconfigures the system accordingly, by changing the values of knobs.

We will see a concrete instance of the programming model in Section 4, with details for each of the above components. The following subsections describe the three main concepts of the programming model, which connect these components. Table 2 summarizes their relationships.

3.1. Knobs

A knob is a piece of program state that the runtime can modify to meet the user-defined intent. Knobs are classified as either platform knobs, such as the CPU clock frequency and the number of cores on which the application’s threads may be scheduled, or application knobs such as the number of times to run an iterative algorithm, the minimum precision of an approximation scheme, or an identifier that selects among a set of possible algorithms to solve a particular sub-problem in the application.

To be useful in an intent-driven program, the values that a knob can be assigned to (its range) should represent different trade-offs between measures which are relevant to the intent. For example, increasing the platform knob that controls the CPU clock frequency can gain a lower processing latency at the expense of a higher energy consumption. Similarly, decreasing an application knob that controls the threshold of an approximation scheme can gain a higher output precision at the expense of a higher processing latency and energy consumption. An intent-driven program with knobs that trade precision for some other measure can be seen as an instance of the approximate computing paradigm (Palem, 2014, Xu et al., 2016, Schlachter, 2018). Early foundational work on this topic can be fond in (Palem, 2003, 2005, Chakrapani et al., 2008).

Though the two classes of knobs (platform vs. application) may achieve their trade-offs very differently, they are treated identically by the runtime. They allow it to reconfigure the system so that the measures change in such a way that the constraint (provided in the intent specification) is achieved.

We will refer to a defined set of knob bindings as a configuration.

3.2. Measures

A measure is a part of the application or system state that is relevant to the intent. Examples of application measures include the output bit-rate of a compression algorithm, or the error of an approximation scheme. Examples of platform measures include input processing latency and energy consumption. By exposing such state as a measure, it becomes available to the runtime as feedback. Based on this feedback, and on the intent declaration, the runtime can compute the knob settings necessary to meet the intent.

3.3. Intents

An intent is an encoding of desired program behavior, expressed in terms of measures. Generalizing existing work on adapting to meet latency constraints (Imes et al., 2015), FAST intents take the form of a constrained optimization problem:

[TABLE]

where $\textup{opt}\in\{\min,\max\}$, $f$ is the objective function, $M=\{m_{0},\ldots,m_{n}\}$ is the set of measures, $m_{c}\in M$ is the constraint measure, $g$ is the constant goal, $K$ is the set of knobs, $v_{k}$ the value of knob $k$ and $D_{k}$ the domain of $k$. Solutions to the optimization problem can be expressed in terms of knobs, since the values of measures implicitly depend on the configuration of the system. An execution of a system will be said to meet the intent when the constraint measure $m_{c}$ is close to the goal $g$, while optimizing the objective function $f$ according to the optimization type. Figure 8 shows examples of such an execution. In Figure 8a, the constraint measure performance and goal are illustrated by orange and green lines, respectively. In Figure 8b, the objective function quality is illustrated by an orange line.

It should be noted that, from the perspective of the programming model, alternative formulations of intents are possible. For example, an intent could be a specification of a safety property that the runtime must seek to preserve with some probability. The investigation of such alternatives is part of our future work.

4. FAST Architecture

The FAST system architecture is an instance of the general programming model, implemented as an extension of Apple’s Swift language (Apple, 2019). This choice makes FAST statically typed and memory-safe with predictable performance thanks to the automatic storage management (reference counting) and evaluation strategy (strict). As such, it is suitable for implementing soft real-time applications, making implicit system behavior such as latency or energy consumption easier to control reliably. However, the intent-driven programming model is by no means restricted to the imperative, object-oriented paradigm, since any language in which the rebinding of variables during execution is meaningful can serve as a basis for intent-driven programming.

Figure 2(a) shows a small Swift program that endlessly increments a variable x by a certain step, up to a certain threshold. We will use this program to illustrate FAST’s user interface, which consists of a library API that enables FAST’s runtime to control an application, and a domain-specific language for specifying the intent.

Figure 1 illustrates the FAST architecture, where three interacting components together constitute the FAST runtime: an intent specification compiler, a profiler and a controller. The intent specification compiler (Section 4.3.1) translates the programmer’s intent (Section 4.2)—specified through the library API (Section 4.1.1)—to an efficient representation, suitable for real-time processing. The profiler (Section 4.3.2) computes measure statistics: total statistics offline to construct controller models; windowed statistics online as feedback to the controller (Section 4.3.3).

The next two sections describe the programmer interface, which consists of the library API (Section 4.1.1), and the intent specification language (Section 4.2).

4.1. Library API

The library API consists of a type (Knob), and two functions (measure and optimize). The API is used to instrument applications. This involves providing hooks into the application that the runtime can use to observe and adapt the application state, and identifying the portion of code that should be monitored by the runtime during execution. Figure 2(b) shows the instrumented Swift code after a programmer has identified suitable values (measures), variables (knobs) and loop (optimize) in the base code, and wrapped them in the corresponding function or constructor calls.

4.1.1. The Knob Type

From the user’s perspective, the type Knob<T> is a type-safe immutable cell that replaces a constant in the base program, and enables the runtime to adapt the cell’s value. In our example, threshold and step become knobs and their original values are used to initialize the Knob type. These reference values make it possible to compile and execute the instrumented application as a normal Swift program, with the original semantics. Thus, reference values represent the knobs’ values if no runtime adaptation is possible. The Knob initializer also takes a string to identify the knob to the runtime.

Because knobs are mutated by the runtime between executions of the main processing loop (Section 4.1.3) they must be declared in an enclosing scope, meaning that, in a terminating application, they remain defined after the routine is executed for the last time. However, the variable encapsulated by the Knob type remains referenced also when execution reaches the end of the scope where the knob was declared, since the runtime must have access to such a reference to perform its adaptation. Thus, to avoid memory leaks, the runtime must use only weak weak references to knobs.

The Knob type provides a novel mechanism to combine programmatic manipulation of the application configuration with the runtime’s continuous control in the form of two methods: restrict and control. For example, the programmer can enable or disable certain knobs, based on knowledge outside of the controller’s domain. To this end, the Knob type’s restrict method allows the developer to explicitly define a range of values for a particular Knob. Passed to restrict in the form of an array, the runtime uses this range to constrain configuration space available to the controller for adaptation. Calling the method without any arguments fixes the Knob to the value it had at the time of the method call. The Knob type’s control method can be used to remove any restrictions from previous calls to restrict, making available to the controller the complete set of values for a Knob specified by the knobs section of the active intent.

4.1.2. The Measure Function

The measure function provides a view of the application’s state as feedback to the controller. In our example, a new variable operations is added to the application to inform the runtime about the number of times that x has been incremented. The name that is passed to the measure function is used by the runtime to correlate the given value with the corresponding measure in the intent specification.

4.1.3. The Optimize Function

The optimize function replaces the outer while loop in our example. It takes as parameters: a name (incrementer), a list of knobs that the runtime should use for control, and a routine (block of code) that should be monitored to provide feedback to the controller, and an optional window size over which measure statistics are computed.

The runtime obtains the feedback from the routine through side-effecting function calls, and thus the type of the routine is Void -> Void. The window size segments the sequence of iterations into conceptual computation blocks. For a sufficiently small window size, the application behavior is assumed to be sufficiently uniform that average measure values of the previous window are representative of the iterations of the next window. On the other hand, the window size should be large enough that the windowed statistics filter out transients, caused by rare and unsystematic events. Thus, the window size is typically identified by the application developer, who will be a domain expert, familiar with the expected behavior of the application under different conditions.

4.2. Intent Specification

Figure 3 shows a grammar for the FAST Intent Specification Language. In this figure, $\{\cdot\}$ and $\langle\cdot\rangle$ denote a set and a sequence of elements, respectively. The arity of a function $f$ is denoted by $|f|$. The set of names of knobs declared in an intent specification $s\in\textsf{Spec}$ is denoted by $K_{s}$. The set of names of measures declared in $s$ is denoted by $M_{s}$. Figure 2(c) is an example intent specification for the incrementer application in Figure 2(b). An intent specification consists of two main parts: an encoding of an optimization problem, and a description of the degrees of freedom along which the system may operate.

4.2.1. Intent

The intent section encodes an (optionally) constrained optimization problem and consists of five parts:

• •

The name of the optimize routine (incrementer in our example) that the intent should affect. This is correlated with the name passed to the optimize function.

• •

The optimization type, one of min or max.

• •

The objective function, an expression in terms of the declarations of the measures section.

• •

The constraint measure, the one from the measures section (latency in our example) that the runtime should control.

• •

The constraint goal, the value (0.1 seconds per iteration in our example) of the constraint measure that the runtime should achieve.

The intent section expresses a high-level specification of what it means for the application to perform well, in terms of the measures which, notably, can be both intensional and extensional.

4.2.2. Measures

The measures section declares measures that should be observed by the runtime. These declarations serve as an environment for the intent section. Currently, measures may only have the Double type, but any totally ordered type that supports the operations used in the objective function could be supported, and the constraint measure could be of any type for which equality is defined.

Measures correspond to observable platform signals and expressions in the base application, in terms of which the intent is expressed. Throughout program execution, their current value serves as feedback to the runtime.

4.2.3. Knobs

The knobs section defines the possible configurations, or configuration space that the FAST runtime can select from during execution to solve the optimization problem specified in the intent section. The knobs section does this through a set of knob definitions that each consist of a name, a range expression that evaluates to a list of constants, and a reference value. The name associates the knob definition with Knob instance in the application. The range is a list of values that the knob can be set to, which must be of the same type as the knob instance’s type parameter. The optional reference value is used to override the reference value passed to the Knob constructor (Section 4.1.1) to provide an initial value for the knob when the application is executed without control, and in the very beginning of a controlled execution.

In addition to the basic knob ranges, the knobs section supports an optional knob constraint—an arbitrary Boolean expression over the knobs—which makes it possible to specify non-uniform configuration spaces. The knob ranges together generate the cross product of the knob settings, that is, all possible configurations that the system supports. The knob constraint is then used to remove all configurations that do not satisfy it. This is useful when there is some kind of dependency between the knobs. For example, there may be cases when certain combinations of knob settings are not meaningful, such as when a knob is a parameter for a sub-algorithm that is enabled or disabled by another knob, or when some global restriction affects what values a set of knobs can be set to simultaneously. Another use for knob constraints is to prune out redundant configurations that expose analogous tradeoffs between the measures that the intent depends on. Such pruning can both save time and energy in profiling the system before it is deployed, and in computing schedules during runtime.

Knobs typically correspond to platform settings or constants in the base application, whose value determines some aspect of system behavior. In non-adaptive applications, such constants are judiciously chosen by the application developer to achieve reasonable expected-case behavior, or exposed to users as parameters. Improperly setting these constants is a notorious source of performance issues (Huang et al., 2015, Rabkin and Katz, 2013, Wang et al., 2018). By exposing knobs to the runtime as variables, the system allows its behavior (as observed through the measures) to adapt to changes in the intent, or in the operating environment and helps eliminate performance bugs due to poor choices of constants.

4.3. Runtime

The main components of the runtime are: an intent specification compiler that makes the programmer’s intent available to the rest of the system, a profiler that observes the behavior of the executing application, and a controller that uses these observations to configure the system so that the intent is met.

4.3.1. Intent Specification Compiler

Users specify intents in files separate from the Swift application code. Compilation is also separate: Swift is a compiled language, and thus the program is compiled into an executable before runtime; FAST intent specifications are interpreted at runtime. This approach has some benefits, compared to expressing intents within the Swift source code: intent specifications can easily be passed to an external system, such as a profiler, or updated over a network, without the need for expensive recompilation or complex binary plugin architectures. The FAST intent specification compiler translates intent specifications into a form that permits evaluation without significant interpretative overhead (Carette et al., 2009), by transforming abstract syntax into nested Swift closures.

4.3.2. Profiler

The profiler collects statistics about measures. The statistics are used to (1) construct models that the controller uses to predict configurations’ measure values and (2) serve as feedback to the controller during execution (Section 4.3.3). Figure 4 shows such a model for the incrementer application (Figure 2).

Statistics with two different horizons are collected. First, total statistics are computed, based on all the observed values of each measure. These averages are representative of the over-all behavior of the system with respect to each measure, and are thus used to construct controller models. Second, window statistics are computed, based on a sliding window of observed values. This window size, a parameter of the optimize function (Section 4.1.3), can be used to dampen noise in the measures, at some cost in the ability to react to legitimate abrupt changes in measure values. A small window size means that short spikes in measure values can cause oscillation in the controller, while a large window size can cause unacceptable lag in adaptation.

For each type of horizon, two statistics are computed: averages are used in place of point samples of measure values; variances are used for debugging purposes, to estimate the reliability of averages used in controller models. An important consideration when computing statistics in the context of iterative applications is that incremental (constant-time) algorithms (West, 1979) must be used, since the size of the set of observations over which statistics are computed is potentially unbounded.

4.3.3. Controller

The FAST runtime interacts with the controller component through a protocol with a single method that, given an intent specification and values for each declared measure, returns a schedule. A schedule is a function that, given a non-negative integer index, returns a configuration. A configuration is an object with an apply method, that can be used to reconfigure the system—that generally comprises both application and hardware. This interface allows for many different types of controllers. The intent parameter determines the resource scheduling problem that the controller must solve, the measures enable feedback control, and the indexed form of the return type supports schedules that reconfigure the system at every iteration.

Next, we describe two example instance of this protocol.

Unconstrained Optimizing Controller

This controller solves the optimization problem specified in the intent, without taking into account the additional constraint. By default it performs a grid search, and chooses the optimal profiled configuration. This applies to both streaming and non-streaming applications. This controller can be extended with meta-optimization heuristics (Claesen et al., 2014) to find optimal configurations at runtime when exhaustive search is not possible, such as when some knobs are continuous.

Constrained Optimizing Controller

This controller solves the optimization problem specified in the intent on average across a window of iterations. For FAST intent specifications, this can be achieved robustly and efficiently using feedback control and optimization (Hellerstein et al., 2004, Filieri et al., 2017), based on a controller model that consists of pre–recorded measure values (Figure 4(b)) for each configuration that the system can be set to (Figure 4(a)), which is obtained through profiling (Section 4.3.2). The optimal schedule is found by first identifying all constraint-compatible schedules, that is, collections of configurations that can be interleaved to meet the intent on average across a window, as illustrated in Figure 5. Among these, the schedule that optimizes the objective function is selected for execution over the next window.

5. Analysis of Intent-Driven Programs

Analyzing adaptive software is strictly harder than analyzing non-adaptive software. The difficulty arises due to both the number of dimensions along which the system can adapt and that adaptation happens over time. Thus, extending a programming language with intents drastically alters its semantics, and also introduces several classes of bugs. Though a full treatment of testing and verification for intent-driven programs is too broad for one paper, the following sections briefly introduce a notion of cost semantics for intent-driven programming, define some simple static analyses that are useful in this context, and describe a testing approach for iterative intent-driven programs.

5.1. Cost Semantics

While many different cost semantics have been proposed, they share the property that the cost of an expression is compositional (Blelloch and Greiner, 1995, Spoonhower et al., 2008). In other words, an expression’s cost is solely determined by the cost of each of its sub-expressions, and the rule that binds them together. If this algebraic system captures the real cost of computation across different machines with respect to a set of parameters, then we obtain a useful abstraction of real computational cost. Most existing cost semantics only model a specific kind of cost; e.g. time or memory. To extend such a semantics to an intent-driven language, we must further abstract away the the details of the computation’s resource usage. We call this an asymptotic cost semantics. As long as the resource is: (a) not reusable, (b) measurable for every single execution, and (c) its cost is additive, then the cost of a sequence of executions of a single expression can be modeled by a sequence of i.i.d. random variables, conditional on the value of the expression’s input. Further, the average of this sequence converges to some fixed value with an i.i.d sequence of inputs, by the law of large numbers. We call this value the asymptotic cost of an expression $e$ with respect to the underlying machine $M$, the resource $r$ and the distribution of the inputs $d$ and denote it by $C[e;M,r,d]$.

This semantics tries to capture the average (and thus cumulative) cost instead of the cost of each call. Intuitively, this means that the impact of compiler optimizations and external disturbances may be smoothed out in the long run, and the asymptotic cost semantics offers a more robust and manageable way to model the behavior for further tuning, in contrast to call-wise cost semantics and even relational cost semantics (Çiçek et al., 2017).

A convenient property of an asymptotic cost semantics is that if we “unroll” the loop (i.e. this infinite sequence) $n$ times (denoting $e;e;\ldots;e$ by $e^{n}$), then:

[TABLE]

where the inequality would become strict only after some sort of (program) optimization. From this, we can further define a lower bound for our asymptotic cost:

[TABLE]

which characterizes (gives an upper bound for) the best cost that (program) optimization could achieve asymptotically.

This notion of asymptotic cost semantics provides a natural way to understand FAST program behavior. Further, it provides a distinct advantage over other (non-asymptotic) cost semantics, since constrained optimal parameter tuning is easily achievable with it and almost always (that is, with probability one for all constrained non-degenerate cases which we will elaborate below) better than tuning each execution independently. Let us consider the knob control problem in FAST. Suppose we have an expression $e_{k}$, which depends on a parameter $k$ that corresponds to application knobs and a machine $M_{k^{\prime}}$, which depends on a parameter $k^{\prime}$ that corresponds to platform configuration knobs both defined previously in Section 3.1. Our cost functions $C[e_{k};M_{k^{\prime}},\cdot,d]$ represent measures defined in Section 3.2. To minimize the asymptotic cost, we solve an infinite system corresponding to our intent defined in Section 3.3:

[TABLE]

where $o$ is the resource corresponding to the objective function in the intent, $r_{l}$ is the resource we want to constrain, and $\mathbf{R}_{l}$ is the constraint value. Notice here that, although the cost is defined differently for every different intent, the restrict API (Section 4.1.1) merely changes the domain of optimization and thus (1) the original asymptotic cost still provides an upper bound after restriction and (2) all the information contained in the original cost function can be reused.

The above is equivalent to the following system:

[TABLE]

where $A_{l,k}=C[e_{k};M_{k^{\prime}},r_{l},d]$, $w_{k,k^{\prime}}$ is the weight corresponding to each configuration $(k,k^{\prime})$, $\mathbf{R}$ is the constraint value vector, and we can denote the corresponding optimal schedule $\{(k^{*}_{i},k^{\prime*}_{i})\}^{\infty}_{i=0}$. A uni-constraint version of this equivalence has been established and studied by Imes et al. (2015).

It is easy to see that:

[TABLE]

where $(k^{**},k^{\prime**})$ is a solution of the corresponding system without iterating:

[TABLE]

The equality happens either when the system is unconstrained, or the system is degenerate. This inequality shows what we stated earlier: in the long run, optimal tuning with our asymptotic cost model almost always outperforms tuning with a non-asymptotic cost semantics (i.e., tuning executions independently).

5.2. Static Analysis

The FAST architecture separates the specification of programs from the specification of intents. The resulting flexibility comes at the cost of possible program errors, when the definitions in the two parts of a FAST program are inconsistent. For example, for a program to be correct, uses of the Knob type (part of the library API described in Section 4.1.1) must correspond to entries in the knobs section of an associated intent specification (described in Section 4.2). In addition, the optimize construct (Section 4.1.3) takes a list of knobs and passes them to the runtime. Using static analysis techniques, the system can provide meaningful feedback early during FAST application development, and eliminate the possibility of certain types of runtime errors. This subsection presents three static analyses, illustrated in Figure 7, which are specific to the implicit programming model.

5.2.1. Finding Unused Knobs

Knobs defined in the intent specification but not declared as a Knob type are ignored by the runtime. On the other hand, declared knobs without configurations in the intent cannot be used in trade-offs while tuning the system. This can be detected statically by collecting the list of knobs defined in the intent, and those declared in the FAST application code, respectively. The analysis reports the difference, if any, between the two lists of knobs, and marks them as unused to aid in further analysis.

Define $K_{I}$ to be the set of knobs defined in the intent file, $K_{D}$ to be the set of knobs declared in the FAST application code, $K_{O}$ to be the set of knobs passed to the optimize construct, and $K_{A}$ to be the set of knobs affecting the body of optimize construct. A knob $k\in K_{A}$ if there is a branch of execution which depends on the value of $k$. Then the unused knobs $K_{UU}$ are defined as $(K_{D}\setminus K_{I})\cup(K_{I}\setminus K_{D})$. The uncaptured knobs $K_{UC}$ are defined as $K_{D}-K_{O}$. The unaffected knobs $K_{UA}$ are defined as $K_{O}-K_{A}$.

5.2.2. Finding Uncaptured Knobs

In the case where a knob is declared, but is not passed to the optimize construct, it is not controlled by the system. We say that these knobs are uncaptured. An analysis finds such knobs and emits a warning.

5.2.3. Finding Unaffected Knobs

Even when a knob is captured, the user may forget to use it, or inadvertently misuse it in the program. Any tuning done by FAST of such a knob will have no effect on the system, meaning that the runtime will be unable to exploit any trade-offs exposed by this knob. Profiling can expose the presence of such knobs, which will correspond to near-identical entries in the measure table (Section 4.3.2). However, such dynamic analysis can be prohibitively expensive when the configuration space is large. A more efficient alternative is to use static analysis to identify such situations. The analysis begins by building a data flow graph starting from the optimize construct. For each node in the graph, it computes the knobs that affect it. Given the annotated graph, it is possible to compute the list of all effective knobs for the optimize construct, and issue a warning when this list is missing some declared knob.

This definition of an unaffected knob amounts to an all-or-nothing identification problem, and the optimization problem to be solved by the controller may be ill-defined in the presence of such knobs. Therefore, we did not include sensitivity in our static analyses. Surely, some form of sensitivity (how the initial condition will affect the solution) similar to the “condition number” of a linear system can be defined for our control problem, to detect whether the control system is functioning well. However, this would be computationally expensive, input-dependent and platform-dependent. On the other hand, finding a branch of code that possibly will not be controlled by some knob at runtime is a cheap solution that is both input-independent and platform-independent. To reiterate the main difference: the statistical approach is to detect whether the system is ill-“conditioned” while our current approach is to find whether the system is ill-defined.

5.3. Testing

Traditional testing, based on hand-crafted test cases, becomes unfeasibly labor-intensive for intent-driven programs. Random testing, and its statistical perspective on correctness, scale to adaptive applications. Random testing produces a distribution of test cases that elicit all possible (including both representative and worst-case) behavior. Computing an evaluation criterion, which produces a set of possible outcomes, over a set of test cases produces a distribution of outcomes. Correctness can thus be phrased as a hypothesis over this distribution, say, that a test case picked from the test case distribution (with the desired coverage) produces a negative outcome with a small probability.

In this section, we make this approach to evaluation concrete for intent-driven applications, by describing how to generate test cases based on an intent specification, and by defining an application-agnostic evaluation criterion. We use this criterion to show that three example adaptive applications behave correctly on a test corpus, derived from the intent specification.

5.3.1. Evaluation Criteria

Implementing an intent-driven program starts with implementing a traditional program, which is done according to standard software development practice. That typically involves the implementation of automated tests. These tests should validate the correct behavior of the program under both normal and exceptional operating conditions, that is, for a set of program inputs and combinations of program parameter values that sufficiently reflect the use cases of the application. These tests do not validate the correct behavior of the instrumented, intent-driven program. Crucially, the ability of the application to react to changes in the operating environment or user intent is not validated.

We devise a largely application-independent evaluation criterion that captures bugs influencing the overall system’s adaptability. This criterion is constructed by comparing the tested application’s execution trace—as controlled by FAST—to an oracle—constructed from a set of traces corresponding to application executions in fixed configurations.

5.3.2. Oracles

We consider two types of oracles: A and B.

Oracle A represents a minimal requirement: that the adaptive application should do better than a non-adaptive system in some respect. For example, embedded real-time systems are provisioned to deliver performance on—possibly rare—worst case inputs, at the cost of resources such as energy. A well constructed adaptive system—i.e., with the right instrumentation and intent—should achieve sufficient performance (given the intent), while using fewer resources than the system that always assumes the worst case. This type of oracle could be constructed by looking at the controller model, and configuring the system according to its performance measure, or by computing a set of execution traces, based on the intent, and selecting the one with the best overall performance. This access to global, posterior knowledge is why these executions are called oracles.

Oracle B models ideal adaptive behavior. Such an oracle can be constructed from a set of fixed-configuration executions in an iteration-wise fashion. At every iteration, the oracle’s measure values are chosen from those of the fixed-configuration execution that best meet the intent. An oracle for testing the constrained optimizing controller is close enough to satisfying the equality constraint while optimizing the objective function.

To be clear, these two notions of oracle are approximations. They are intended to capture salient aspects of the application’s adaptive behavior, while remaining tractable and simpler than the implementation they are modeling. Consequently, for example, there will be situations where an adaptive FAST execution may perform better than Oracle B (for example, when no configuration comes close to satisfying the constraint).

When the application that is being tested contains uses of the Knob type’s restrict API (Section 4.1.1), valid oracle definitions must take into account the corresponding dynamic change to the configuration space. Oracles may only use those configurations that remain available to the runtime that is controlling the tested application. In other words, in the presence of the restrict API, valid oracles are parameterized by the model that is available at each iteration.

5.4. Verdict Expressions

Based on an oracle, we can construct a verdict expression that maps a test case to one of a set of possible outcomes, such as {PASS, FAIL}. The definition of these outcomes depends on the chosen oracle, since, as discussed in the previous section, oracles may represent different reference points for the system under test. To compare an adaptive execution against an oracle, a notion of error is needed, and this notion will vary depending on what the oracle is designed to optimize.

Listing 1 shows how a verdict expression can be constructed based on Oracle A, and the three auxiliary definitions given below in terms of the execution $X$, which can be either Oracle or FAST:

• •

The mean absolute percentage error (MAPE) $E(X)$ of the constraint measure value for $X$, compared to the constraint goal.

• •

The cumulative objective function $F(X)$ of $X$.

• •

The global constraint measure error threshold $T$ of the constraint measure versus the constraint goal.

Listing 2 shows how a verdict expression can be constructed based on Oracle B, and the following additional auxiliary definitions, given in terms of the executions $X_{1}$ and $X_{2}$, which can be either Oracle or FAST:

• •

The objective function advantage $A(X_{1},X_{2})$ which is defined as 0 when $F(X_{1})\leq F(X_{2})$ and defined as $\frac{F(X_{1})-F(X_{2})}{\max(|F(X_{1})|,|F(X_{2})|)}$ otherwise.

• •

The global constraint measure error threshold $T_{E}$ of the constraint measure versus the constraint goal, and the global objective function threshold $T_{F}$.

5.5. Test Suite

Table 3 describes test cases that validate FAST’s basic runtime and controller functionality. Test cases fall into two categories: those that validate normal system behavior (1-4), where the expected verdict is PASS, and those where the system executes outside of intended operating conditions (5-6), where the expected verdict is FAIL or INVALID. In some tests, qualitative aspects of the application executions are interesting, beyond the verdict. For example, for test case 6, the adaptive execution’s behavior should attempt to come as close to the goal as the available configurations allow.

6. Experimental Evaluation

Table 4 shows the three applications we use to evaluate FAST including their knobs and measures. The table also shows source–lines–of–code counts for each original (non-adaptive) application, wrapper code (when applicable), and FAST instrumentation added to enable adaptation. As illustrated by these counts, software of any size can be controlled by FAST.

Table 6 further details each application’s knobs. Knobs may be ordinal—such as the decimation ratio of the SAR application (Section 6.1)—or categorical—such as the sub-pixel refinement method of the X264 application (Section 6.3). All ordinal knobs discussed in this paper are discrete.

The cost of the optimization task that needs to be performed by the controller for every window varies across applications. For the constrained optimizing controller (Section 4.3.3), an optimal schedule will result in one change during the course of the window (of size $w$), and is a combination of two near-optimal configurations. The number of possible schedules is thus at most $N^{2}*w$, where $N$ is the number of configurations in the controller model.

Figure 8 shows experimental results for the three example applications. The two plots for each application show window averages of the constraint measure (performance) and objective function (quality), to compare FAST behavior to Oracles A and B. As summarized in Table 5, these results illustrate that, by adapting dynamically to perturbations in the intent, FAST consistently outperforms Oracle A’s quality, while meeting the performance constraint (on average once the performance has stabilized after a perturbation). FAST also performs on par with Oracle B and, interestingly, even beats it in terms of quality. This is possible because Oracle B is only an approximation of the ideal adaptive behavior, which meets the intent iteration-wise, choosing a single configuration at a time. FAST, in contrast, interpolates between configuration over a window of inputs, allowing it to meet the performance constraint while staying in higher-quality configurations on average.

The fixed configurations (gray lines in Figure 8) show that the measures used to control the system (performance and quality in this case) can be highly noisy. They fluctuate to the point where they may change order over the course of an execution. This change can cause a controller to oscillate, as the information provided by the controller’s model conflicts with the feedback it receives. This situation is to be expected when intensional measures such as performance or energy are used for control, but it can also arise for extensional measures that are input-dependent, such as the x264 measure quality (as in Figure 8c). Such behavior can be mitigated statically to some extent, by ensuring that the model contains configurations whose measures are sufficiently separated along the measures that will be used for control.

6.1. Synthetic Aperture Radar (SAR)

SAR is a signal processing pipeline that detects objects in a sequence of synthesized signals. Both the size of filters (Coarse Decimation Ratio, Fine Decimation Ratio) and granularity (Number of Beams, Number of Ranges) are tunable knobs. While SAR and the numerical application described below were implemented in pure Swift, SAR is the only one that relies on Grand Central Dispatch to run sub-tasks in parallel due to its pipelined nature.

6.2. Jacobi Iterative Method

The Jacobi Iterative Method is an algorithm that approximates the solution of a diagonally dominant system of linear equations. We implemented a parallel version of the algorithm in Swift. The parallelism was constructed using a POSIX style threading system supported in Swift. During execution, in addition to the number of available cores and the core frequency, the controller can choose the number of iterations after which the threads should synchronize. The application is non-trivial to synchronize, because reducing the number of iterations after which to synchronize changes the overall time to reach convergence and the speed of meaningful iterations. This application illustrates the generality of FAST, in that it works equally well to control streaming and computation bound applications along with applications that have different resource utilization patterns.

Furthermore, the Jacobi Iterative Method experiments along with the x264 experiments show several advantages over auto-tuning systems such as OpenTuner. While dynamic adaptation is the most obvious advantage, since OpenTuner provides a single configuration in which to run the application throughout the entirety of the execution, FAST allows knobs to be dynamically set in response to environmental fluctuation. Since OpenTuner provides a single configuration in which to run the application, there might not exist a configuration using which the application can achieve the required intent, this outlines another advantage of FAST over OpenTuner, since FAST can still achieve the intent by switching between an under-provisioned and an over-provisioned configuration in an execution window. This capability is illustrated in Figure 8(e), where the two last performance goals (13 and 20) are not close to any fixed configuration’s performance, but can be met by FAST on average by interpolating between configurations. Similarly, in application such as x264, in which performance is highly dependent on the input, there can be a significant amount of variation in performance using a single configuration, FAST mitigates this using feedback control.

6.3. x264 Video Encoder

Modern video encoding—represented by x264 (Merritt and Vanam, 2006)—is a quintessential streaming application, exhibiting several characteristics that make it a useful test case for an intent-driven programming. It exposes a myriad of parameters and measures with different trade-offs, making up-front configuration of this application something of an art (x, 264, Botha, 2013). For the purpose of evaluation, the x264 C++ code base was instrumented using the Swift foreign-function interface. The x264 application uses a typical high–level pipeline for signal processing. We have exposed four of its application parameters as knobs for testing purposes.

In the following subsection we present experimental results for an example use case based on the FAST library API functions restrict and control. The example was implemented as an extension of the x264 application, and shows that the system can be adapted to suit the needs of a diverse range of real-world application using minimal developer effort.

6.3.1. Use Case: Explicit Higher Quality Demand

Developers might explicitly want a range of frames to be encoded at a significantly higher quality, while still maintaining the original intent. The Knob type’s restrict method enables this by setting a knob that affects quality to a particular value or range (e.g., of higher motion estimation or constant quantizer). As an example, consider footage produced by a CCTV camera. For most of the day, nothing of interest is captured and, hence, low quality footage suffices. During times of interest, the developer might disallow configurations that produce low quality video. To this end, the developer can use the restrict API call to set the range of values that a knob can be assigned to get higher quality frames. With these restrictions in place, the controller uses the remaining knobs to meet the intent. Once the time of interest has passed, the knob restrictions can be lifted (using the control method) and the controller is free to use the complete range of values listed in the intent specification.

Figure 9 shows the execution of such an application with the following intent:

[TABLE]

The controller minimizes energy per frame until the execution reaches the range of inputs that is of special interest to the developer. Via a call to the restrict method the developer sets a restriction on the range of values that a particular Knob can take. Consequently, the controller is forced to choose from among the configurations that are chosen by the developer (which produce higher quality frames). Figure 9 shows that the frames in the restricted range are encoded at a higher quality than the rest of the frames, while still meeting the constraint, but that a higher amount of energy is required to encode each frame over this period.

While the execution is in this restricted range the controller intelligently copes with the change by selecting values for the other knobs so as to be able to meet the constraint. For example, the controller chooses configurations with a greater number of cores and higher core frequencies which results in an increase in energy required to encode a frame as shown in Figure 9.

During this time the controller still meets the intent while providing higher quality at the cost of a higher energy to encode a single frame. Once the inputs in the range of interest have been processed and the restriction on the Knob values has been lifted using a call to the control method, the controller can return to choosing Knob values that minimize energy while meeting the performance constraint (i.e. minimize objective function under the active constraint).

After the call to control the state of the controller is reset. Hence, the controller takes a small period to adjust to the new configurations. Implementation of an application with such requirements requires no more than two API calls to the FAST runtime.

This example illustrates a capability that is easy to achieve in FAST, but difficult using prior work. The PowerDial System adjusts knob configurations dynamically to meet a target performance despite environmental fluctuations (Hoffmann et al., 2011), but it provides no mechanism for the program to change the available set of knobs. In fact, changing available knobs in PowerDial would require recompilation, while in FAST it requires only a few method calls. Thus, this example demonstrates an advantage of the combination of procedural and continuous control of adaptation that is possible in intent-driven programming. The small amount of changes needed to incorporate this complex capability in an application using FAST also demonstrates a key usability advantage over prior work.

7. Conclusions and Future Work

This paper presents the FAST architecture for intent-driven programming, and describes some fundamental aspects of computing that are affected by extending a language with intents. This extension reopens problems for which reasonable solutions are available for traditional languages, such as what kinds of programming language constructs are useful, how to formalize the semantics of the language, and how to validate program correctness. Answering these questions is part of our future work.

Specifically, we plan to extend the language with a richer, composable syntax and more general optimization to support multi-objective and multi-constraint intents, as well as additional knob kinds, such as dense ordinals. Such extensions will require a controller component with the corresponding capabilities. For example, support for multi-constraint intents could be added using algorithms for solving mathematical programming problems, such as the simplex or interior-point methods. Notably, however, such a change would not require any changes to the programming model. Generalizing the knob and measure concepts, for example to accommodate input features, will improve the ability of FAST to control applications whose inputs exhibit distinct phases. Runtime extensions to support active profiling will also be helpful in that regard.

We also plan to explore the topic of correctness of intent-driven programs, including static and dynamic analyses that check that assumptions under which components operate correctly (such as various properties of the controller model) are not violated. Leveraging statistical information in the runtime will make it possible to monitor and predict the violation of more general assurance criteria.