ConfigTron: Tackling network diversity with heterogeneous configurations

08/13/2019 ∙ by Usama Naseer, et al. ∙ 0

The web serving protocol stack is constantly changing and evolving to tackle technological shifts in networking infrastructure and website complexity. As a result of this evolution, the web serving stack includes a plethora of protocols and configuration parameters that enable the web serving stack to address a variety of realistic network conditions. Yet, today, most content providers have adopted a "one-size-fits-all" approach to configuring the networking stack of their user facing web servers (or at best employ moderate tuning), despite the significant diversity in end-user networks and devices. In this paper, we revisit this problem and ask a more fundamental question: Are there benefits to tuning the network stack? If so, what system design choices and algorithmic ensembles are required to enable modern content provider to dynamically and flexibly tune their protocol stacks. We demonstrate through substantial empirical evidence that this "one-size-fits-all" approach results in sub-optimal performance and argue for a novel framework that extends existing CDN architectures to provide programmatic control over the configuration options of the CDN serving stack. We designed ConfigTron a data-driven framework that leverages data from all connections to identify their network characteristics and learn the optimal configuration parameters to improve end-user performance. ConfigTron uses contextual multi-arm bandit-based learning algorithm to find optimal configurations in minimal time, enabling a content providers to systematically explore heterogeneous configurations while improving end-user page load time by as much as 19



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1. Introduction

Web page performance significantly impacts the revenue of content service providers (CSP) (e.g., Facebook or Google) and content distribution networks (CDNs), with recent studies showing that a 400ms increase in page load times (PLT) can reduce revenue by 4.3% (bing, ; brutlag2009speed, ). Yet, uniformly improving web performance is becoming increasingly challenging because of the growing disparity in the network conditions (bandwidth, RTT and loss rates) (singh2015flexiweb, ; wang2014speedy, ; al2011overclocking, ; erman2015towards, ) and devices used by end-users (ruamviboonsuk2017vroom, ; nsdi:wprof, ; www:wprofx, ). To address this disparity and improve quality of experience (QoE), the networking community is constantly developing new protocols and configuration suggestions for user-facing web servers (AKA, edge servers), e.g., PCC (dong2015pcc, ), Vivace (vivace, ), and BBR (card2017wellbbr, ) at the congestion layer (L4) and QUIC (quic, ), SPDY (spdy, ) and HTTP2 at the application layer (L7).

The optimal choice of protocol and parameters is contingent on the network infrastructure (wang2014speedy, ; erman2015towards, ; karlsson2007tcp, ; singh2015flexiweb, ; al2011overclocking, ; tcpwise, ; atc:pantheon, ; ruffy2018iroko, ; jay2018internet, ; li2018qtcp, ), website complexity (butkiewicz2011understanding, ; nsdi:klotski, ; netravali2016polaris, ; wang2016speeding, ; nsdi:wprof, ), and end-user device (ahmad2016view, ; ruamviboonsuk2017vroom, ; www:wprofx, ). Furthermore, innovations along any one of these three dimensions will lead to the invention of new protocols and the re-evaluation of default configuration parameters. Although different regions and ISPs leverage radically different networking infrastructure and mobile devices (ahmad2016view, ), a majority of CSPs continue to employ a “one-size-fits-all” approach to configuration, which results in sub-optimal performance and high tail-latency in certain regions (al2011overclocking, ; tcpwise, ; wang2014speedy, ; erman2015towards, ).

Figure 1. PLT comparison

1.1. Tuning Configurations Today

Most attempts to tackle this growing diversity involve manual analysis of the performance of different configuration options in specific regions or on specific websites. Unsurprisingly, while several CSPs expose configuration knobs to their costumers (vcl-fastly, ), many customers do not take advantage of them due to manual labour required (vcl-fastly, ) to tune these knobs. Alternatively, when operators tune their stack the focus on a limited set of knobs (akamai-knobes, ).

In this paper, our focus is on tuning a board set of configuration knobs across the transport (e.g., congestion control algorithm) and application layers (e.g., HTTP version). Table 1 highlights the knobs currently being tuned by our system. In addressing this problem, we focus on first understanding the challenges associated with tuning and quantify benefits of tuning before we explore the systems and algorithmic considerations introduced by fined-grained cross layer tuning.

Layer Protocol Options Default Value Values tested
TCP congestion_control Cubic Cubic, Reno, Vegas, BBR
initcwnd 10 MSS 1, 4, 10, 16, 20, 30
slow_start_after_idle 1 0, 1
low_latency 0 0, 1
autocorking 1 0, 1
pacing pfifo_fast pfifo_fast, fq
Web App HTTP Protocol 1.1 1.1, 2
Table 1. Web stack configuration parameters.

To illustrate the difficulty of tuning server configurations, in Figure 1, we compare page load times of CDN servers when configured using popular tuning techniques. Specifically, Bayesian Optimization (pelikan1999boa, ) (BO) (e.g., CherryPick (alipourfard2017cherrypick, )) a popular statistical technique used for tuning systems configurations (duan2009tuning, ; herodotou2011starfish, ; van2017automatic, ; alipourfard2017cherrypick, ; fb-bo, ), operator hand-tuned configurations (discussed in § 2), closed-loop offline-learning, and an oracle technique. For default configurations, we used Linux’s default (Table 1).

Hand-tuned configurations are manually selected and are thus, naturally, coarse-grained: unsurprisingly, we observe that while hand-tuned improves median it fails to provide optimal performance across varying network conditions hence the negative improvement values.

Bayesian optimization, aims to quickly discover “good” configuration; while fine-grained, this approach is relatively static, it does not re-evaluate old choices and is thus unable to adapt to network dynamics. In Figure 1, we observe effects of this rigid behavior with wildly fluctuating performance.

Lastly, we explore an offline model which learns on traces from prior days, and applies the learned model on network connections for the next day. Offline model is fine-grained but with limited dynamicity: the trained model is unable to react to realtime issues. Unfortunately, due to the high-dimensionality of the Internet’s dynamics these realtime issues are the norm not the exception (jiang2016cfa, ; sigcomm:metis, ). We observe in Figure 1, that offline performs closest to the optimal (oracle’s behavior) but still falls short because of its inability to react in real time.

Our brief analysis of modern approaches to tuning highlights the need for a highly dynamic and fine-grained approach to tuning the configurations of the web server’s network stack. An approach which is able to adapt, in real-time, to changes within the underlying network.

Layer Option Top configs. in NA (cross-CSP) % heterogeneity outside NA Instance of heterogeneity observed

HTTP version H1.1(44.3%), H2(55.7%) 4.7% NA H2 - Asia H1.1
Max header list size 16384 (100%) 0% None
Header table size 4096 (100%) 0% None
Max concurrent streams 100 (44%), 128 (56%) 1% NA 100 - EU 128
Initial window size 65536 (71%), 65535 (15%), 1M (14%) 1.9% NA 1048576B - Asia 65535B
Max frame size 16,777,215 (81%), 16384 (19%) 0% None

TCP (L4)
ICW {10 (62%), 4(20.5%), 24(5.3%)} MSS 6.9% NA 24 MSS - Asia 10 MSS
RTO {0.3(9.2%), 1(82.6%), 3(8.2%)} sec 2.3% NA 3s - EU 1s
RWIN {29200(57.4%), 14600(8.2%), 42780(6.8%)} bytes 3.6% NA 29200B - Asia 12960B

Table 2. Heterogeneity in configs. across 5 regions

1.2. ConfigTron

In this paper, we eschew the notion of a homogeneous approach to tuning web server configurations and instead argue for a “curated” approach to configuring the web server’s network stack. In particular, we argue that edge servers should be configured and setup with the optimal protocols and configuration parameters required to serve each of the incoming connections, e.g., an edge server serving high loss, low bandwidth connections may employ a lower initial window size than one serving low loss, high bandwidth connections.

To this end, we argue for a simple but powerful server architecture that introduces flexibility into the network stack, enables reconfiguration and systematically controls configuration heterogeneity. We also introduce a contextual multi-armed bandit-based learning algorithm, an embodiment of domain specific insights, which tunes configuration in a principled manner to find optimal configurations in minimal time. Taken together our system design and learning algorithm enables a CSP/CDN to systematically explore heterogeneity in a dynamic and fine-grained manner while improving end-user performance in a principled manner.

The design of ConfigTron faces several practical and interesting challenges:

  • [topsep=0.1ex,leftmargin=2wide=0pt]

  • Non-stationary: network conditions are dynamic (changing every few minutes (zhang2001constancy, ; urvoy2005stationarity, ; lu2005characterizing, ; balakrishnan1997analyzing, ; jiang2016cfa, )). Thus, ConfigTron must quickly and continuously learn optimal configurations.

  • Non-Gaussian noise: Most CSPs focus on improving tail latency (tail-at-scale, ; dynamo, ; sigcomm:metis, ) which is often caused by non-Gaussian processes (e.g., last mile contention (sundaresan2016home, ), mobile device limitations). Thus, ConfigTron must address non-Gaussian noise.

  • High-dimensionality: Content personalization, diverse devices and last mile connections (sundaresan2016home, ) introduce high dimensionality that make offline closed loop approaches in-effective (jiang2016cfa, ; nsdi:pytheas, ). Thus, ConfigTron explore an online and scalable approach to tackle high dimensionality of internet conditions.

  • High-cost data: Generating data for learning requires testing configuration and impacting user performance – a very costly endeavor. Thus, ConfigTron must minimize impact to end users.

The key insight of ConfigTron is to simultaneously operate in two modes depending on the “quality” of the performance model: essentially, ConfigTron bootstraps model building intelligently and adaptively selects samples that speed up model convergence then, at steady state transitions to a greedy-mode that stochastically samples random points to iteratively improve performance: ConfigTron tackles data-scarcity and high-data cost by clustering clients and sampling across the cluster.

ConfigTron uses a contextual multi-armed bandit designed explicitly to continuously learn an optimal configuration within a minimal number of exploration steps. Our ensemble fuses the stateful exploration of Gaussian-bandit (§ 4.1.2

) with the non-determinism of Epsilon-bandit: statefulness enables informed exploration of the configuration space while the randomness allows re-sampling of old configurations and continuous searching to identify optimal configuration. The re-evaulation provided by resampling enables ConfigTron to directly tackle non-Gaussian noise within the domain and the non-stationary property of the problem. The data-collected by the ensembled is encoded in a decision tree – which enables quick and easy classification but is also amenable to automatic generation of rules for the CDN server.

To demonstrate the benefits of ConfigTron, we conducted large-scale simulations to analyze the implications of various design choices on the performance and accuracy of ConfigTron. Our evaluations show that ConfigTron provides as much as 19% (upto 750ms) reduction in PLT for the median case and a 36-80% (900ms-1400ms) improvement in the tail latency. Given the recent arms race by CSPs to improve web performance, we believe that ConfigTron’s modest performance improvements will result in significant revenue savings.

2. Empirical Study

In this section, we analyze CSPs to determine the extent of configuration tuning (§ 2.1) that exists today and quantify the implications of configuration tuning (§ 2.2).

2.1. Probing web-servers configurations

We aim to understand if modern CSPs employ homogeneous configurations, as suggested by anecdotal evidence, or heterogeneous configurations to tackle diversity in Internet ecosystem. To this end, we developed a tool that combines and extends existing measurement tools (yang2014tcp, ; oliver-icw, ; icdcs:ig, ) to recognize modern protocol versions and inter-operate with TLS. Our tool actively probes web servers and infers configuration parameters by inspecting the packet-headers and the server’s reaction to emulated network events (e.g., packet loss). We encourage the reader to peruse prior-work (yang2014tcp, ; oliver-icw, ; icdcs:ig, ) for further explanation.

We fingerprint configuration choices across three layers: application/L7 and transport/L4 for the Alexa top 1k websites. We compare the configurations for the same CSP across five different regions (North America, South America, Asia, Europe and Australia). Using North America (NA) as the baseline, Table 2 presents the degree of heterogeneity (percentage of web servers that configure differently in NA vs other regions) observed for the Alexa top 1k.

Observation-1: Heterogenity across CSPs In column 3 (cross-CSP analysis), we observe that different CSPs use different configuration values in NA. While some of the heterogeneity can be attributed to differences in default values across different OSs, we do observe (in column 5) that a nontrivial amount of CSPs are using non-default values, e.g., using an initial congestion window (ICW) value of 24 MSS.

Observation-2: Homogeneity within a CSP: In column 4 (cross-region analysis), we focus on the configuration used by a specific CSP across different regions. Specifically, this column denotes the percent of CSPs that use a different configuration in NA than in any of the other four regions. We observe that only a small number of CSPs tune their network stack to account for regional differences. We observe that the highest amount of tuning occurs at L4, with 7% of the CSPs tuning the ICW differently in NA than in other regions, e.g., uses a value of 24 MSS in NA but 10 MSS in Asia.

Figure 2. ConfigTron Architecture.
API Interface Description ID = initConfigProfile() Creates new config. profile. setProfileParam(ID,key,value) Sets parameters to profile. getProfileParam(ID,key) Gets parameters for profile. deleteConfigProfile(ID) Uninitializes the profile. AssignProfile (SocketID,ID) Assigns a socket to a specific profile. AssignProfile (IP-Prefix,ID) Assigns a prefix to profile. Table 3. ConfigAgent API
Figure 3. Learning Framework.

2.2. Implications of Configuration Tuning

Taken together, these observations indicate that while modest tuning is performed on a per-provider basis, this tuning is not specialized to properties of specific regions. Next, we quantify the impact of reconfiguring the networking stack by conducting a large scale study of the impact of selecting the optimal configurations over the default configurations across different network conditions and websites.

These experiments are conducted in a testbed: each webpage is loaded five times and the median PLT is computed. Within the testbed, we explored (1) a wide range of realistic network conditions using NetEM – we extracted the network conditions from four real-world datasets (fcc, ; caida, ; mawi, ; atc:pantheon, ) (explained in § 6.1), (2) a variety of websites on the Alexa Top-1k list belonging to various categories; news, social networks, sports, business, e-commerce, and entertainment, and (3) the protocol configurations in Table 1. We reconfigured these protocols using IOCTL socket calls, modifying IP tables or modifying application modules.

We begin, in Figure 1, by exploring the implications of using sub-optimal configurations. We observe that in the median case, there is a 8-18% improvement in performance when oracle’s recommended optimal configuration is used (found through brute-force exploration in testbed). While the number may appear small, they can result in tremendous revenue savings in the order of millions (bing, ; brutlag2009speed, ) and more in the developing regions where CSPs are investing heavily to improve those conditions (fb:drone, ; google:ballon, ). Unsurprisingly, it is within the conditions representative of these developing regions (the tails of the distribution) that reconfiguration provides the most benefits.

Dissecting the need for tuning congestion control: Next, we use the dataset from Pantheon (atc:pantheon, )

to re-affirm our hypothesis that tuning transport layer is necessary to account for underlying heterogeneity observed in networking infrastructure. Specifically, Pantheon tests different transport protocols from servers spread out across the world. From the Pantheon data-set, we observe that emerging protocols, e.g., BBR, PCC, or Remy, which promise to use probing or machine learning to improve performance, do not provide uniform improvements. In particular, we observed that in many situations BBR is suboptimal, performing 3X to 10X worse than the optimal congestion control. Moreover, no congestion control is optimal for more than 25% of the networks tested and the median congestion control is optimal for only 6% of the networks. Despite the rapid improvements at the transport layer, there is still a need for configuration tuning and informed-selection of the protocols.

3. Architecture

At a high-level, our re-architected edge server consists of four components (Figure 3): The HTTP server which operates as it does today, serving content and collecting performance metrics for each connection. The Configuration Manager, runs the learning algorithm (§ 4) on telemetry collected from the servers. The ConfigTron-API which abstracts vendor specific configuration details and provides a uniform interface for configuring web serving stack’s parameters across different vendors and collecting performance metrics. A Configuration Agent runs on each web server and uses the information received from the Configuration Manager to configure the network stack through the ConfigTron-API.

While this architecture is fundamentally simple, adoption in an incrementally deployable manner is challenged by the following practical limitations:

Interfaces and Abstractions: Today, a web server’s configuration parameters are exposed in an ad-hoc manner and require a combination of IOCTL and setsockopt commands to tune the kernel. Additionally, the appropriate performance metrics are not readily exposed.

Incremental Deployability: Many CSPs and CDNs leverage well-established code bases. A key challenge to getting immediate adoption is to employ a solution that exposes the novel interfaces and abstractions, required by ConfigTron, in a manner that does not require modifying or rewriting existing applications or kernels.

Scalable Learning: Section 4 presents a data-driven learning framework for identifying and efficiently learning appropriate configurations. Central to realizing this framework, is a system that scalably supports the modules required to effectively learn appropriate configurations.

3.1. ConfigTron-API

The ConfigTron-API (Table 3) presents a uniform interface over the web server’s serving stack thus abstracts away OS and web server specific details. This simplified interface enables the Configuration Agent to easily configure the network stack and collect performance metrics without having to understand and reason about vendor specific details or their implications. Central to the design and implementation of the ConfigTron-API is a web server architecture that naturally supports flexibility and fine-grained reconfiguration of individual connections. Unfortunately, traditional kernels expose only a limited subset of the configuration parameters for flexible reconfiguration. For example, some parameters (e.g. tcp_auto_corking) can be configured on the connection level; where as, others can be configured on the process level (e.g. HTTP version) and yet, even others can only be configured on a global scale (e.g., tcp_low_latency). Using ConfigTron at a coarser granularity, e.g., global or process-level, either limits the type of connections that can be supported on a machine or limits the space of configurations that ConfigTron can tune. To address this challenge, there are several options ranging from user-space TCP/IP stacks (dunkels2004lwip, ; jeong2014mtcp, ; picotcp, ) and introducing kernel modules or eBPF programs, to leveraging virtualization (VM/containers). Below, we briefly discuss challenges associated with different design choices:

  • [topsep=0.1ex,leftmargin=2wide=0pt]

  • Default Linux interfaces (e.g., sysctl and netlink.): Most changes made through these interfaces are global w.r.t kernel and all processes and connections share these kernel settings. This provides incremental deployability but limits flexibility.

  • Containers and VMs: The network stack is shared between all containers and limited in flexibility. VM provides the right isolation with the appropriate level of flexibility but the overheads of devoting one VM per configuration are both high and lead to resource fragmentation (§ 6.4.3).

  • Syscall Interposition: Some socket settings can be changed from user-space through setsockopt(). However this requires changing application code which is undesirable. Alternatively, we can employ system call interpositions, i.e., LD_Preload, to intercept system calls and reconfigure the network stack without directly changing the application. Although this provides us with the right level of isolation, LD_Preload results in high resource over-heads (§ 6.4.3).

  • eBPF: Recent works (brakmo2017tcp, ; tran2019beyond, ) have explored eBPF to tune TCP socket settings. This is a promising direction, in works, and currently lacks tuning all parameters listed in Table 1.

  • Kernel Module: In face of these limitations, our design of ConfigTron introduces a kernel module which directly exposes all the parameters and provides direct control over the parameters at the connection level by modifying the kernel’s data structures, e.g., SKBuff for Linux. The use of a kernel module ensures that the kernel is not changed while simultaneously allowing us to introduce the functionality required to provide fine-grained control over server’s configuration parameters.

3.2. Configuration Agent

The Configuration Agent is the glue logic between the Configuration Manager and ConfigTron-API — uses information provided by the Configuration Manager to configure the ConfigTron-API. Our design of the Configuration Agent explores the following design choices:

Push-based design: Our design chooses a proactive approach, where the Configuration Manager constantly pushes configuration mappings to the Configuration Agent which caches them in its local KV. This approach ensures that ConfigTron does not incur any connection startup delay for waiting for the Configuration Agent to pull configuration mappings from the Configuration Manager.

Imperfect Data: The Configuration Agent may not have a configuration mapping, if the incoming client’s features (§ 4.2) are not known (eg. first connection from a previously unseen prefix). In these situations, the Configuration Agent uses the default configuration and simultaneously queries the Configuration Manager for a better mapping.

Long lived Connections: For long lived connections, the network conditions may necessitate a change in the connection’s configurations 111Network conditions change on a time scale of minutes (zhang2001constancy, ; balakrishnan1997analyzing, ; jiang2016cfa, ).. In these situations, the Configuration Agent receives updates from Configuration Manager and applies the new configurations to the connection. 222Recall, Configuration Agent periodically sends performance information to Configuration Manager and receives new configuration mappings based on these performance statistics.

3.3. Configuration Manager

The manager runs in a centralized location, e.g., a Data Center or locally in a Point of Presence (PoP). The implications are later explored in § 6.4.1. It is charged with running the learning algorithms (§ 4) and disseminating the configuration maps to the Configuration Agents’ cache (§ 3.2). The Configuration Manager disseminates and collects data from the Configuration Agents using a combination of well-understood techniques. In particular, ConfigTron leverages a distributed asynchronous messaging system (ZeroMQ (zeromq, )) for all communication between the Configuration Agents and the Configuration Manager. For the configuration maps and the A/B information, Configuration Manager broadcasts to all Configuration Agents. Whereas for reporting performance data and for making one-off-request for configuration maps, the Configuration Agents use unicast.

3.4. Deployment considerations

Prediction workflow operates in two logically separate phases: The first involves updating the learning algorithms and Network Class (NC) rules at the Configuration Manager. This is time-consuming process as it involves processing large amount of data. The second phase is a fast, real-time process that uses rules generated by first phase for live users.

On every model update, the Configuration Manager pushes NC rules (§4.2) and learning model decisions (§4) to the front-end servers’ Configuration Agents. These rules are translated into key-value stores, eg. learning model decisions are stored as NC (key) and configuration (value). For accurate NC classification, the Agents track real-time network characteristics of the clients (§4.2). Unlike Pytheus (nsdi:pytheas, ), any change in client characteristics triggers a instant change in their NC (and prediction result), as the classification is a simple key-value store lookup, rather any further computation. A network change event (eg. congestion) will result in change in one of the features (eg. congestion at bottleneck link will likely increase RTT), triggering a change in NC as the new features (increased RTTs) might lie in a different NC, according to the NC rules stored at the front-end.

4. ConfigTron’s algorithm

Improving performance by employing heterogeneous configurations presents an interesting learning problem: Next, we formulate the problem, identify the challenges, and presents an ensemble to address this challenge.

Problem Formulation: Given a set of configurations (C = ), network conditions (N = ), websites (W = ) and a function, f(), that maps a website, network condition, and configuration to metric of web page performance (e.g., Page Load Time (PLT) or SpeedIndex (ST)). Note that: returns the web page performance metric value for applying configuration to a client loading website on network . In this paper, we use PLT as the metric for web page performance and note that PLT can be easily replaced with other metrics. Our goal is to solve equation 1 and find a configuration (c) that minimizes f() for a given combination of a website () and a network condition ().


Solving the black-box function, f(), requires exploring through the sample space. Two possible candidate algorithms are:

  • [topsep=0.1ex,leftmargin=2wide=0pt]

  • Brute force (sigcomm:oboe, ) tests each possible configuration one by one until the entire space has been explored.

  • Bayesian optimization (BO) (pelikan1999boa, ; brochu2010tutorial, )

    is an effective global optimization strategy, that uses a prior probability function to capture the relationship between the objective function (f(c,n,w) Eq

    1) and the actual data samples observed. Bayesian optimization models f(c,n,w) as a Gaussian process (brochu2010tutorial, ). The Gaussian process is a distribution of candidate objective functions and is used to select the next promising point, (c*), which is then evaluated on a connection. The Gaussian process then updates its posterior belief by adding the new observation f(c*,n,w) to the set of seen observations. As a result, with each new observation, the space of possible candidate functions gets smaller and the prior gets consolidated with evidence. To explore the search space in a principled manner, Bayesian optimization includes an Acquisition function (brochu2010tutorial, ) which selects the next point to test by calculating the loss associated with computing the next point and selects the point with the least loss as the next target point for testing.

Challenges: Both approaches are sub-optimal in a production setting for our use-case due to several reasons: (1) non-stationary network conditions (network conditions change every few minutes), (2) non-Gaussian noise (sigcomm:metis, ) (tail latency can not be modeled as a Gaussian process), (3) BO can be highly sensitive to its hyper-parameters when the underlying data has non-Gaussian loss (§ 6.3), (4) costly data collection (collecting data requires testing on end-users which can impacts PLT and CSP revenue), and (5) data scarcity (testing on individual users requires each user to generate a tremendous number of connections but a user may only visit the site a few times) (6) Gaussian process is limited in its ability to model non-continuous space (sigcomm:metis, ).

Workflow: Figure 3 presents our process for alternating between a directed and a stochastic search process for building our performance model. Central to the design of ConfigTron is the intuition during the early phases of modeling-building, the search should be directed to speed the process; however, at steady-state, once a good model is built, the search should be more stochastic to iteratively improve the model and tackle non-systematic noise.

ConfigTron clusters clients based on similarities and uses these clusters as a “context” to determine the quality of the model. Given this context, we employ a multi-armed bandit which alternates between two distinct exploration mode as a function of the “context”. For exploiting the search-samples and data, our bandit builds a performance model (i.e., a decision tree) which is used by the exploitation arm to make efficient predictions

4.1. Learning Optimal Configuration

ConfigTron makes two requirements of the learning algorithm: First, the algorithm should accurately predict the optimal configuration (§ 4.1.1). Second, when the algorithm is unable to predict the optimal configuration, it should identify the next samples such that it has a higher probability of improving prediction accuracy (§ 4.1.2).

4.1.1. Prediction with Machine Learning

For prediction, we explored a number of different techniques including Support Vector Machines (SVMs), Decision Trees (D-Trees), and Random Forests (RF). Using cross-validation, we found their accuracies to be fairly close: SVM 93.3%, DT 95.6%, RF 96.1%. Decision Tree hits the sweet spot, providing comparable accuracy to other models tested and being efficient enough to build and update at scale.

A decision tree is a supervised, classification model that predicts class labels for new data items. In our case, a decision tree predicts configuration parameters for new network connections. Each node, except for the leaves, captures a binary classification decision, predicated on a subset of the feature set. Leaves contain configuration parameters for features which satisfy the classification decision along the path.

4.1.2. Adaptive Sampling with Bandits

To enable adaptive sampling, ConfigTron leverages a contextual, multi-armed bandit. Our bandit has three arms: (a) Gaussian process – to quickly discover a “good” solution, (b) epsilon bandit – to re-sample data points and counter the key problem with the Gaussian bandit, and (c) learning bandit (D-Tree), which exploits knowledge (data samples) gathered by the other bandits to predict effectively. A key distinction between the Gaussian-based exploration and the epsilon-based exploration is that Gaussian-bandit samples based on clusters, whereas the epsilon-bandit samples across the whole population.

  • [topsep=0.1ex,leftmargin=2wide=0pt]

  • Exploration Arm-1 (Gaussian process): The Gaussian process (GP) bandit enables directed exploration to quickly discover a “good” (may not be optimal) solution when no information exists for a network class through the use of an acquisition function. There are multiple acquisition functions available (brochu2010tutorial, ) and we use Expected Improvement(EI) because of its well-documented success (alipourfard2017cherrypick, ; gardner2014bayesian, ; duan2009tuning, ). This search process includes two terminating conditions: a threshold on EI and minimum of number of data points to explore. Gaussian process is better suited than other statistical techniques (coordinated descent, hill climbing, or random sampling) due to its ability to optimize arbitrary black-box functions without domain-knowledge. For example, coordinated descent requires domain knowledge to determine the order inwhich to explore paratemeter dimensions – barring such domain knowledge, coordinated descent may get stuck in a local optima  (alipourfard2017cherrypick, ).

  • Exploration Arm-2 (Epsilon-bandit): The Epsilon-bandit (A/B testing) uses a stochastic model to select samples. This allows ConfigTron to resample old data points and overcome issues endemic with Gaussian process (and Bayesian Optimization in General), e.g., Gaussian noise, non-stationarity, and optimizing parameter dimensions with non-continuous spaces. The network operator bounds the random exploration by defining the degree of randomness: a parameter that trades-off between the speed and the impact of exploration on end-user QoE. A high degree of randomness improves exploration but results in a negative impact on client’s QoE due to constantly changing configurations.

  • Exploitation Arm The exploitation arm uses the prediction algorithm discussed above (§ 4.1.1). It also aids in bootstrapping a new NC. When a new NC shows up, the exploitation arm predicts a candidate configuration using the trained model. The predicted configuration is used as one of the initial samples in bootstrapping the Gaussian process bandit for the new NC.

Our ensemble fuses these bandits: in essense, ConfigTron is constantly switching between exploitation and exploration. During exploration, ConfigTron uses the Gaussian Process to quickly discover a “good” configuration and subsequently switches to the greedy epsilon-bandit to move towards optimal. The transition from Gaussian to epsilon occurs when a specific parameter (EI) of the Gaussian bandit exceeds a threshold.

4.2. Discovering Network Classes (NC)

At a high level, ConfigTron makes the assumption that users with very similar network conditions will require identical configurations. This assumption is based on studies (jiang2016cfa, ; mukerjee2015practical, ) which show that users with similar conditions observe similar performance. Thus, ConfigTron defines network classes (NC) as groups of users with similar network properties. ConfigTron clusters clients based on properties ranging from performance characteristics (loss, bandwidth, and latency) and device type to path characteristics (AS-path, client-ISP, geo-location). 333

This data is collected throughout the connection’s life time and as more data is collected the connection’s cluster is re-evaluated. During the TCP handshake, the path and performance characteristics are collected using IP address and publicly available data (e.g. RouteViews). The performance characteristics are estimated using the packets exchanged during the handshake and refined as more packets are exchanged. The device characteristics are captured once the user-agent string is captured.

Clustering can be automatic, using conventional techniques, e.g., K-means or hierarchical clustering, and by using domain-knowledge, e.g., Facebook network class 

(fbconn, ), PolicyAtoms (caida:policyatoms, ) Hobbit (imc:hobbit, ) or CFA (jiang2016cfa, ) . Alternatively, CFA (jiang2016cfa, )

can be used to reduce feature set to only those features that matter – tackling the potential challenge of data sparsity due to high dimensionality. Although ConfigTron can incorporate any of the aforementioned techniques, our prototype uses kmeans to classify clients in network classes. As the objective is to group clients with similar web performance, the number of classes (or k) is determined by evaluating the spread of performance metric within a NC (bounded by one standard deviation from mean). We use kmeans due to its simplicity. ConfigTron initializes with offline-generated NCs (using historical traces and testbed simulations) that evolve with time if performance of clients within same cluster diverge. We do not implement CFA due to unavailability of public dataset with required features (§


4.3. Design Choices for Gaussian Process

In addition to the acquisition function, and stopping parameters, designing a gaussian process requires choosing a bootstrapping method. In our situation, the bootstrap methodology is especially crucial for ensuring that the Gaussain-Bandit quickly finds appropriate samples. Recent works (alipourfard2017cherrypick, ; duan2009tuning, ; Bilal:2017:TAP:3127479.3127492, ) have demonstrated the applicability of three distinct bootstrapping approaches: (i) random, in which the initial configurations are randomly selected; (ii) domain-specific, in which prior domain knowledge, captured through operator interviews or simulations offline, are used to rank configurations to sample; (iii) Latin Hypercube Sampling (LHC) which divides input space into partitions and selects a sample from each partition to spread the samples evenly across space (lhs, ).

In this work, we use LHC to bootstrap the learning process. LHC has been found to aid bootstrapping Bayesian optimization by reaching an optimal decision quicker (mckay1979comparison, ). We observed LHC to speed up exploration in comparison with others by reducing the number of optimization steps by 2-3X, as the bootstrapping samples are spread evenly across space. A perfect rankings of configurations cannot be known prior to actually testing configurations, leading to ranking-based bootstrapping being sub-optimal to LHC. In addition to LHC, ConfigTron’s exploitation arm also aids in selecting the bootstrapping samples for new network classes (§ 4.1.2)

5. Prototype

In this section, we describe our prototype of ConfigTron, focusing on the implementation highlights.

ConfigTron-API: is a user-space application that updates settings in kernel via a kernel module exposed as a character device (char-device, ). Our use of a kernel module to tune the network stack’s enables us to deploy our system without changing the kernel. We used Linux’s vanilla implementation for key-value store (kernel-hashtable, ).

Configuration Agent: has an agent residing within kernel module and gets its cues from ConfigTron-API to tune configurations. It wraps functions provided by kernel’s congestion controls through tcp_congestion_ops and reuses their functionality, while at the same time changing appropriate fields in sock and dst_entry structs. For reporting a connection’s performance stats, its user-space part logs stats from a socket’s tcp_info struct and Apache’s logs. HTTP is tuned by routing requests to differently tuned apache instances.

Configuration Manager: is developed in 1435 LoC (Python). The Configuration Manager uses SciLearn (sklearn-dt, ) for D-Tree and GPyOpt (gpyopt, ) for Bayesian optimization. For communication between the Configuration Manager and Configuration Agents, ConfigTron uses ZeroMQ (zeromq, ). For D-Tree, we use an optimized version of CART algorithm (implemented in SciLearn by default). We use entropy for the information gain as the measure of quality of split, 80 as the minimum number of leaf nodes, 2 as minimum number of samples needed for split and do not limit depth of tree. For Gaussian process, we use init_sample=4, min_sample_tested=7 and EI=5% thresholds.

6. Evaluation

To understand and quantify the benefits of reconfiguring the networking stack, we evaluated ConfigTron using both a large-scale trace driven network simulator and a live prototype deployment of around hundred clients. Together, these two approaches enable us to understand the behavior of ConfigTron under real and dynamic conditions as well as to simultaneously analyze the implications of individual design choices on the entire systems.

6.1. Large Scale Trace Driven Simulations

Figure 4. CAIDA traces
Figure 5. MAWI traces

Datasets: To simulate client activity, we use data from four sources: (i) CAIDA (caida, ), packet traces collected at Equinix data-center in Chicago in 2016, (ii) MAWI (mawi, ), packet traces from Japan WIDE backbone (in December 2017), (iii) FCC (fcc, ), a nation-wide home broadband dataset collected by the FCC, (iv) Pantheon (atc:pantheon, ), a data set of client sessions between different regions. This work does not raise ethical concerns as the public datasets used are anonymized.

Generating client sessions: A client session is defined by 3 metrics: (a) session characteristics (bandwidth, latency, loss rates) at the start of connection, (b) time duration after which network changes, (c) sessions characteristics after change. Our simulator processes two categories of client’s session traces: (i) Real-world client sessions are extracted from CAIDA and MAWI datasets. Using the packet traces from these datasets, session characteristics between a pair of end-points and any temporal changes are calculated, (ii) Simulated client sessions use bandwidth, latency and loss rates distributions, extracted from FCC and Pantheon datasets. Changes in network (duration after which network changes and revised session characteristics) follow distributions from real-world packet traces (CAIDA, MAWI). For detecting and measuring change in network, we used Bayesian Online Changepoint Detection algorithm (adams2007bayesian, ) due to its effectiveness for similar use-case (sigcomm:oboe, ). An IP-distribution, extracted from CAIDA, MAWI traces, models the temporal aspect of client’s connections (time at which a client connection (or IP) is seen in trace). Collectively, with the four datasets we are able to simulate 16M sessions from different geographic regions thus providing us with good coverage over a wide range of representative network conditions.

Optimal Configurations: Using a testbed, we re-create the network conditions from traces and for each network condition we emulate all combinations of configurations (Table 1

). For each {network condition, configuration} pair, each webpage in our corpus is loaded multiple times with a browser and the performance, or page load time (PLT), of each {configuration, website} is measured. The final result is stored in a large tensor that maps {network condition, configuration, website} to PLT – called the


Simulator (Virtual Browser): Our simulator takes the PLT-Tensor and client session traces as input. The simulator processes the trace and simulates the client’s browsing behavior and interaction with ConfigTron by (i) processing the time series to characterize the connection 444Each end-user is modeled as a time series – measured network conditions indexed over time. This time series enable us to simulate client sessions by modeling the changes in network conditions, faced by these clients., (ii) using the learning framework in §4 to determine the appropriate configuration to apply to this connection, (iii) simulating the webpage load process by using the PLT-Tensor to determine PLT for the client given the selected configuration, and (iv) feeding the result of the simulation back into configuration manager to enable continuous learning.

Limitations: The PLT-Tensor does not include TCP slow start after idle as we do not re-use TCP connections in testbed to ensure clean measurements. Additionally, the simulator is unable to emulate different end-user devices.

Alternate algorithms We compare ConfigTron against:

i-Brute-force (Brute): For each client, this algorithm exhaustively explores all configurations – a distinct configuration per client-connection – and use the best one.

ii-Brute-force w. Network Classes (Brute+NC): Brute force where exploration is spread out across each network class.

iii-Bayesian Optimization (BO): Bayesian Optimization for individual user.

iv-Bayesian Optimization w. Network Classes (BO+NC): Bayesian Optimization across groups of users.

v-CherryPick with Network Classes (CherryPick+NC): BO+NC with hyper-parameters specified in (alipourfard2017cherrypick, ).

vi-Multi-armed Bandit with Network Classes (MAB+NC): uses multi-armed bandit algorithm with different configurations as the arms, using weighted epsilon-greedy agent. This strategy uses one arm per config. and build individual models for each NC.

vii-Optimal: Puts an upper bound on improvement. Optimal parameters for a session are determined by searching the PLT-Tensor for the configuration that minimizes PLT.

Note: ConfigTron maintains an estimate of a client’s network using its historical interactions. In case when client’s network changes, optimal uses the the new, correct view of network, whereas ConfigTron and other baseline algorithms use the historical estimate for prediction.

6.2. Effectiveness of ConfigTron

Figures 5,5 present the improvement in PLTs over default configurations (Table 1) across the different algorithms for multiple traces. ConfigTron outperforms all alternatives, consistently delivering lower PLTs. ConfigTron improves median PLTs by 19% for Pantheon (500ms), 16% (750ms) for MAWI, 11.2% (280ms) for FCC and 10.1% (250ms) for CAIDA.

Unlike ConfigTron, the static strategy (Default) is unable to account for differences between networks and websites (§2). While, the dynamic strategies (Brute and BO) are able to apply different configurations to different users, these approaches assume that the network remains static and are unable to adapt to fluctuations in network behavior. Moreover, due to its inability to adjust to fluctuations, BO often explores over 90% of configuration space without achieving the target EI. Brute+NC, BO+NC and CherryPick+NC improves over the prior by amortizing the costs of learning but fail to adjust to non-Gaussian variations.

We observe fairly similar improvements for FCC and CAIDA as both traces cover network conditions from USA. The improvement over default increases for MAWI and Pantheon traces, as they have higher RTTs and packet loss rates. Eg, their 75th percentile RTTs are greater than 100ms, as compared to 34ms for FCC and CAIDA. We observe that higher reconfiguration benefits are seen for network conditions representative of under-developed regions (high RTTs and loss rates, low bandwidths), as the default configurations are mostly tuned for developed regions networks (dukkipati2010argument, ; wang2014speedy, ).

6.3. Benefits of Contextual Bandits

(a) Cold start
(b) Bandits contribution
Figure 6. Convergence

Next, we analyze the benefits of ConfigTron’s multi-armed bandits. We analyze two versions: ConfigTron-NoGP, a version of ConfigTron without guided exploration. , and ConfigTron-NoDT, a version of ConfigTron without the decision tree. For the two alternatives, Figures 5(a), plots the median distance from optimal across all network classes, for a given iteration of algorithm optimization.

The key observations are that: (i) initially all algorithms perform comparable because of a lack of data (iterations 1 fig6), (i) as more data is gather ConfigTron outperforms both approaches because of its ability to blend benefits of both approaches – essentially efficient exploration and effective exploitation (iterations 3-10), (iii) eventually, with sufficient data ConfigTron-NoGP is able to use the decision tree’s predictive power to achieve near ideal performance (iterations 100+), finally (iv) while ConfigTron and ConfigTron-NoGP perform comparable for median performance at steady-state when sufficient data exist, performance at the tail is still different – the use of guided exploration enables ConfigTron to explore specific configurations parameters that improve tail latency.

Finally, In Figure 5(b) we analyze the contribution by each bandit. Initially when ConfigTron is exploring new configurations, GP bandit is largely used for a guided exploration. However as more data is collected with time, GP bandit’s contribution is overwhelmed by DT bandit, highlighting the benefits of greedy exploitation. This result stresses the point that a per-class guided exploration is over-shadowed by across-class exploitation, when large data is available. Takeaways: The complexity provided by ConfigTron’s contextual bandit enables ConfigTron to simultaneously provide good median and excellent tail performance.

6.4. Design Choices

Next, we analyze the impact of several of ConfigTron’s design choices on the performance of ConfigTron.

6.4.1. Configuration Manager Design

The Configuration Manager can run locally in a PoP or more centrally within a data-center. The choice of location is a fundamental trade-off between the size of data available for learning and the speed with which the system can react to changes: An appropriate choice ensures high accuracy while providing a delicate balance between both extremes.

We evaluate both scenarios in our simulator: In the local design, there’s a separate Configuration Manager for each PoP (trace), while for the global case there’s a single Configuration Manager which for all traces (PoP). We evaluate several situations, with different latencies between managers and the web servers. We observe that while the global Configuration Manager is able to make slightly better predictions at the tail (less than 2% relative) In particular, we observed that despite the larger data set, the global Configuration Manager does not show much improvement in predictions because the different traces are for different regions with distinctly different network conditions (only 17% overlap).

6.4.2. Frequency of model updates

The frequency of model updates has a significant impact on ConfigTron performance – while existing work have demonstrated that updates as infrequent as hour may suffice (nsdi:pytheas, ; jiang2016cfa, ), our discussion indicate that operators may want to explore less frequent updates. Next, we analyze the impact of updating our performance model less frequently: we explore a range of values from every 2 minutes 555 It takes 2 minutes to update the models for 10K sessions. up to every day. We observed that performance at the tails degraded whereas performance at the median remated relatively stable.

6.4.3. Microbenchmarks

Next, we analyze the impact of the Configuration Agent on the web servers. Specifically, we explore CPU, memory and latency overheads of Configuration Agent and the performance implications of having Configuration Agent interpose on each connection. We conducted these tests using the Apache Benchmark tool (ab, ): we conduct our experiments using two servers. One to run the Apache Benchmark tool and another to run the ConfigTron-enabled server. We repeated tests in multiple network conditions, with multiple number of concurrent connections and for multiple websites. We compared ConfigTron against a vanilla server using Cubic (default setting). Apache Benchmark tool showed no overhead of using ConfigTron’s kernel module in term of latency. Similarly, we observed CPU and RAM overheads less than 1%. Any RAM overhead is attributed to kernel module’s implementation of the KV-store (kernel:hashtable, ) used for storing the IP masks to configuration rules.

Alternative Design Choices: We also evaluated alternate design choices described in § 6.4.3. For VMs, we used one VM for each configuration and used Open vSwitch (OVS) (ovs, ) for routing flows to the appropriately configured VM. We also explored the use of LD_Preload to intercept system call and tuned socket using setsockopt(). In comparing both choices with ConfigTron, we observed that the VM-based approach introduced a  20% increase in latency where as the LD_Preload introduced a much smaller latency of 2.2%. We also observed overheads for CPU and Memory utilization: the VM-based approach introduced  30% while the LD_Preload introduced a  5% increase.

Takeaway ConfigTron introduces minimal overheads on the webserver (less than 1%) and is competitively better than alternative design choices which introduce as much as 30%.

6.5. Fairness Implications

Figure 7. Jain’s Fairness

As ConfigTron configuration space covers regular configurations used by linux kernel and current CDNs (Table 2), fundamentally, its fairness implications are bounded by the configurations used in-the-wild today. A number of CDNs use BBR (found to be unfair to Cubic (ruth2019empirical, ; hock2017experimental, ; turkovic3interactions, )) and high ICWs (eg. 30 as ICW). In order to evaluate fairness, we simulate an end-user’s last-mile connection in our testbed. We test multiple representative network conditions (3G, 4G, Cable, DSL etc) with shallow buffers. In each network, we start 5 background flows with default Cubic configuration. We further inject a test flow matching either (i) ConfigTron (each of ConfigTron’s top 10 configuration) or (ii) default BBR. Modern browsers commonly spawn 6 connections for HTTP/1.1 and these experiments evaluate config. fairness among the connections. We collect per flow statistics (throughput, RTTs, loss rtaes etc.) using TCP_Info from server. We further compute Jain’s fairness index to measure the throughput fairness at steady state.

Figure 7 presents the results. Similar to recent studies (ruth2019empirical, ; hock2017experimental, ; turkovic3interactions, ), we found BBR to be mostly unfair to Cubic. However, ConfigTron is fair to Cubic (Jains’s 0.95) for more than 50% of the cases. ConfigTron’s top configuration include Cubic, Vegas and BBR with ICW ranging from 10-30. We do not observe ICWs to significantly impact fairness at steady state as different ICWs with similar CC were observed to be fair with each other. We observed the use of Cubic and Vegas in 6 of top configurations to contribute to ConfigTron’s good Jain’s fairness index. 4 BBR configs in ConfigTron’s top 10 mostly contribute to the unfairness. Removing these configurations (ConfigTron wout BBR) makes ConfigTron even more fair to Cubic for more than 90% of the cases.

6.6. Critical Features and Parameters

Figure 8. Critical features
Figure 9. Critical configuration parameters

In order to understand the impact of input features and configuration parameters on prediction quality, we modified our simulator to train on different subsets of the feature set (or configurations). In particular we focused on subsets of the following features: {website, throughput, latency, packet loss} and configuration knobs: {Table 1}.

Input Features: Recent work (pi2018ap, ) suggests latency as good metric for client aggregation. Using latency as a baseline, Figure 9 plots relative improvement when a set of features is used. The results show that web complexity is a crucial parameter. Without including web-complexity in the feature-list (red-line), median performance is unchanged. This reflects the fact that the impact of network conditions vary depending on the properties of the website – a long understood insight (nsdi:klotski, ; wang2014speedy, ; netravali2016polaris, ; nsdi:wprof, ). Upon further analysis, we observe that impact of web-complexity varies. For example, including web-complexity of simple websites, e.g., Search, provides little benefits where as introducing web-complexity for content-rich sites, e.g., shopping, provides significant benefits to learning.

Next, we analyze the relative importance of reconfiguring different configuration parameters. Our goal is to understand the crucial parameters that must be tuned to significantly improve performance.

Configuration Knobs: Figure 9 plots the results for five configuration options. There are several crucial observations: while the HTTP parameter is crucial. It is not the most important and it is infact third after TCP-CC and ICW. Unsuprisingly the congestion control algorithm (TCP CC) is the most important parameter because this directly controls throughput. The next important, ICW, is a related parameter that aids the congestion control algorithm – and is crucial for short flows. While there are many other parameters, e.g., Auto Corking, in the median case these provide little benefits but provide tremendous benefits at the tail. This implies that improving tail performance requires turning a broader range of parameters to account of the edge conditions that exist at the tail.

6.7. Live Deployment

We deployed ConfigTron on several AWS servers each with 4 cores Intel(R) Xeon(R) CPU E5-2676 v3 @ 2.40GHz and 16 GB of RAM. One of the servers runs the Configuration Manager. We evenly divide the remaining servers: half running ConfigTron-enhanced web servers and the other half running traditional web servers. Our clients were distributed all across the globe using Speedchecker (speedchecker, ). These web clients periodically conduct back to back pageloads for websites from both the ConfigTron-web servers and the traditional web servers. We tested a variety of websites, including websites from Alexa top-100. In total, we had approximately 3200 clients spread across 6 of the continents. The clients conducted pageloads throughout the day, resulting in 100K pageloads in 10 days.

Figure 10. Live deployment

We observed that ConfigTron improves the web performance by 8-10% in the median and 43% in the 95th percentile case. For the highest improvements scenarios, the optimal configuration include either BBR or Vegas for congestion control. We observe a stark difference in the ICW values for optimal configurations: clients in developed regions (EU, NA) use much higher ICW (30-50 MSS), whereas under-developed regions employed comparatively lower ICW (16-24). Note that, optimal ICW for both regions is different from default (10 MSS). Unsuprisingly, majority of the websites which experience greater than 20% improvement are content-rich, eg. sports, news etc.

7. Discussion and Future Work

Here we discuss open questions in ConfigTron’s design:

Offline exploration: Recent works (sigcomm:oboe, ) have highlighted the effectiveness of offline exploration. While the effectiveness of offline exploration is limited for high-dimensionality situations (jiang2016cfa, ; nsdi:pytheas, ), we believe that offline exploration can enhance our approach by providing a pre-build model (or warm model) thus reducing model convergence or providing data for proactively pruning in-effective configurations knobs (van2017automatic, ). As part of future work, we are extending our learning model to incorporate pre-build models.

QUIC, BBR: While ConfigTron has focused on more traditional stacks which use TCP, ConfigTron can operate over new transport layers, e.g., QUIC or BBR. In fact, both QUIC and BBR introduce a larger number of configuration options, in turns, strengthens the case for self-tuning like ConfigTron.

Client Side Changes: Currently, ConfigTron requires no client side changes. However, client side changes can improve ConfigTron’s performance in multiple ways. As part of future work, we are exploring methods to use emerging Javascript APIs (e.g., NetworkAPI (networkAPI, )) to gather client-side features and incorporate them into our learning algorithm.

Security and Equilibrium: Potential implications of self-learning systems include adversarial attacks (sun2015raptor, ) or oscillations. We are working to formulate the interactions between different instances of ConfigTron (i.e., deployments by different CDNs) as a game-theoretic problem to understand the behavior of our system at equilibrium.

Management Overheads: Dynamically reconfiguring the CDN’s protocol stack complicates performance diagnosis and troubleshooting. We plan to investigate methods for reducing this complexity, e.g., minimizing the number of active configuration combinations.

Broader Evaluations and QoE Metrics: As part of ongoing work, we are planning to understand the limits of ConfigTron by evaluating ConfigTron across a broader set of web page QoE metrics (e.g. SpeedIndex).

8. Related Work

Online Global Cross Exploration
Data Data Layer
Remy (winstein2013tcp, ) X X X
PCC (dong2015pcc, ) X X
Pytheus (nsdi:pytheas, ) X
Custard (jay2018internet, ) X X
QTCP (li2018qtcp, ) X X
Cloud tuning (alipourfard2017cherrypick, ; sigcomm:metis, ; zhu2017bestconfig, ; Bilal:2017:TAP:3127479.3127492, ) X
DB tuning (duan2009tuning, ; van2017automatic, ) X X
Table 4. A comparison of algorithms.

Web Performance Many measurement studies (wang2014speedy, ; erman2015towards, ; ghobadi2012rethinking, ; al2011overclocking, ; dukkipati2010argument, ) have explored the performance of different networking protocol settings and the impact of tuning on web performance. Our system builds on the observations from these studies: namely that different configurations are required for different network conditions and websites.

ML + Transport Existing applications of ML to the transport protocol (winstein2013tcp, ; schapira2017congestion, ; dong2015pcc, ; jay2018internet, ; li2018qtcp, ) focus on tuning specific aspects of stack and thus provide limited benefits relative to ConfigTron which tunes across a broader set of layers and parameters(see Section 2). Similarly, while these techniques (dong2015pcc, ) use features from the network, ConfigTron incorporates application features (e.g., website complexity).

Unlike (winstein2013tcp, ) which rely on priori assumptions of the network, ConfigTron builds a performance model-based on live feedback which allows it to adapt to network dynamics. Where as others (jay2018internet, ; li2018qtcp, ; dong2015pcc, ) build models using real time data, they operate on a different granularity – controlling the sending rate of individual servers based on local data (lacking a multi-session view). Instead, ConfigTron operates at the broader level – using data from multiple connections to build a model that controls protocol configurations and parameters, thus making it immediately deployable.

In contrast with (balakrishnan1999integrated, ), ConfigTron builds on contrasting motivation that different CC strategies (eg, loss, delay, bottleneck-bandwidth based etc) react differently to distinct network paths, whereas CM uses same CC (ECN and loss-based, AIMD) for the divergent paths. Unlike ConfigTron which focuses on control over server configurations, others (ruffy2018iroko, ; ghobadi2012rethinking, ) require control over network and endhost to perform appropriate learning and tuning — applicable to data centers.

Self-tuning Systems: The closest related work attempt to tune the configurations of Map-reduce (herodotou2011starfish, ), Databases (duan2009tuning, ; van2017automatic, ), TCP initial congestion window (tcpwise, ; niereducing, ), cloud computing (alipourfard2017cherrypick, ; sigcomm:metis, ; zhu2017bestconfig, ; Bilal:2017:TAP:3127479.3127492, ) and video (mao2017neural, ; nsdi:pytheas, ; sigcomm:cs2p, ; sigcomm:oboe, ) to improve application-specific performance. While our work shares a similar ideology of exploiting heterogeneity, we differ in our methods for learning optimal configuration and in the domain specific solution for implementing reconfiguration.

Specifically, related approaches model (alipourfard2017cherrypick, ; duan2009tuning, ; van2017automatic, ) static workloads where performance metrics do not change with time or explore offline (sigcomm:oboe, ), whereas we propose an online approach to tackle network and workload dynamics. Unlike (tcpwise, ; niereducing, ; liu2016efficiently, ) which tune one parameter, ConfigTron tunes multiple parameters simultaneously–  (tcpwise, ; niereducing, ) tunes a subset of those tuned by ConfigTron where as (liu2016efficiently, ) tunes orthogonal parameter(i.e., Routing).

Recent works (nsdi:pytheas, ; mao2017neural, ) attacks an othorgonal space – video bitrate and CDN selection, whereas we focus on network protocols which support the video transfers. The domains lead to difference in designs. For example, where as Pytheus focus on simple exploitation/exploration with exploration constrainted to cluster-specific data – we explore a contextual bandit with multiple exploration arms and our exploitation arm is able to generalize across clusters.

CrossLayer Optimizations. We differ from existing cross-layer optimizations (bridges2007configurable, ; chen2016dispersing, ; al2011overclocking, ) which introduce APIs to enable the different layers to communicate and react accordingly. Instead, we externalize the optimization logic and present an interface across the different layers to enable an external entity to configure the different layers.

9. Conclusion

In this paper, we argue that “one-size-fits-all” approach to configuring web serving stacks results in sub-par performance for end-users, especially those in emerging regions. This argument stands in stark contrast to the traditional setup of today’s web serving stacks where a single configuration is used for a divergent set of users.

This paper takes the first step towards realizing heterogenity and fine-grained reconfiguration in a principled and systematic manner: our system, ConfigTron, introduces a principled framework for learning better configurations, than default, for a connection by systematically exploring the performance of different configurations across a set of similar connections. We demonstrate the benefits of ConfigTron using both a live deployment and a large scale simulation.


  • (1) Adams, R. P., and MacKay, D. J. Bayesian online changepoint detection. arXiv preprint arXiv:0710.3742 (2007).
  • (2) Ahmad, S., Haamid, A. L., Qazi, Z. A., Zhou, Z., Benson, T., and Qazi, I. A. A view from the other side: Understanding mobile phone characteristics in the developing world. In Proceedings of the 2016 ACM on Internet Measurement Conference (2016), ACM, pp. 319–325.
  • (3) Akamai. Tcp optimizations.
  • (4) Akhtar, Z., Nam, Y. S., Govindan, R., Rao, S., Chen, J., Katz-Bassett, E., Ribeiro, B., Zhan, J., and Zhang, H. Oboe: auto-tuning video abr algorithms to network conditions. In Proceedings of the 2018 Conference of the ACM Special Interest Group on Data Communication (2018), ACM, pp. 44–58.
  • (5) Al-Fares, M., Elmeleegy, K., Reed, B., and Gashinsky, I. Overclocking the yahoo!: Cdn for faster web page loads. In Proceedings of the 2011 ACM SIGCOMM conference on Internet measurement conference (2011), ACM, pp. 569–584.
  • (6) Alipourfard, O., Liu, H. H., Chen, J., Venkataraman, S., Yu, M., and Zhang, M. Cherrypick: Adaptively unearthing the best cloud configurations for big data analytics. In NSDI (2017), pp. 469–482.
  • (7) Apache. Apache benchmark.
  • (8) Archive, M. W. G. T. Packet traces from wide backbone 12/1/17 to 12/7/17.
  • (9) Balakrishnan, H., Rahul, H. S., and Seshan, S. An integrated congestion management architecture for internet hosts. ACM SIGCOMM Computer Communication Review 29, 4 (1999), 175–187.
  • (10) Balakrishnan, H., Stemm, M., Seshan, S., and Katz, R. H. Analyzing stability in wide-area network performance. ACM SIGMETRICS Performance Evaluation Review 25, 1 (1997), 2–12.
  • (11) Bilal, M., and Canini, M. Towards automatic parameter tuning of stream processing systems. In Proceedings of the 2017 Symposium on Cloud Computing (New York, NY, USA, 2017), SoCC ’17, ACM, pp. 189–200.
  • (12) Brakmo, L. Tcp-bpf: Programmatically tuning tcp behavior through bpf. NetDev 2.2 (2017).
  • (13) Bridges, P. G., Wong, G. T., Hiltunen, M., Schlichting, R. D., and Barrick, M. J. A configurable and extensible transport protocol. IEEE/ACM Transactions on Networking 15, 6 (2007), 1254–1265.
  • (14) Brochu, E., Cora, V. M., and De Freitas, N. A tutorial on bayesian optimization of expensive cost functions, with application to active user modeling and hierarchical reinforcement learning. arXiv preprint arXiv:1012.2599 (2010).
  • (15) Broido, A., and claffy, k. Analysis of RouteViews BGP data: policy atoms. In Network Resource Data Management Workshop (Santa Barbara, CA, May 2001).
  • (16) Brutlag, J. Speed matters for google web search, 2009.
  • (17) Butkiewicz, M., Madhyastha, H. V., and Sekar, V. Understanding website complexity: measurements, metrics, and implications. In Proceedings of the 2011 ACM SIGCOMM conference on Internet measurement conference (2011), ACM, pp. 313–328.
  • (18) Butkiewicz, M., Wang, D., Wu, Z., Madhyastha, H. V., and Sekar, V. Klotski: Reprioritizing web content to improve user experience on mobile devices. In NSDI (2015), vol. 1, pp. 2–3.
  • (19) CAIDA. The caida ucsd anonymized internet traces 2016 dataset.
  • (20) Cardwell, N., Cheng, Y., Gunn, C. S., Yeganeh, S. H., et al. Bbr: congestion-based congestion control. Communications of the ACM 60, 2 (2017), 58–66.
  • (21) Chen, A., Sriraman, A., Vaidya, T., Zhang, Y., Haeberlen, A., Loo, B. T., Phan, L. T. X., Sherr, M., Shields, C., and Zhou, W. Dispersing asymmetric ddos attacks with splitstack. In HotNets (2016), pp. 197–203.
  • (22) Dean, J., and Barroso, L. A. The tail at scale. Communications of the ACM 56 (2013), 74–80.
  • (23) DeCandia, G., Hastorun, D., Jampani, M., Kakulapati, G., Lakshman, A., Pilchin, A., Sivasubramanian, S., Vosshall, P., and Vogels, W. Dynamo: amazon’s highly available key-value store. In ACM SIGOPS operating systems review (2007), vol. 41, ACM, pp. 205–220.
  • (24) Dong, M., Li, Q., Zarchy, D., Godfrey, P. B., and Schapira, M. Pcc: Re-architecting congestion control for consistent high performance. In NSDI (2015), vol. 1, p. 2.
  • (25) Dong, M., Meng, T., Zarchy, D., Arslan, E., Gilad, Y., Godfrey, B., and Schapira, M. Pcc vivace: Online-learning congestion control. In 15th USENIX Symposium on Networked Systems Design and Implementation (NSDI 18). USENIX Association (2018).
  • (26) Duan, S., Thummala, V., and Babu, S. Tuning database configuration parameters with ituned. Proceedings of the VLDB Endowment 2, 1 (2009), 1246–1257.
  • (27) Dukkipati, N., Refice, T., Cheng, Y., Chu, J., Herbert, T., Agarwal, A., Jain, A., and Sutin, N. An argument for increasing tcp’s initial congestion window. Computer Communication Review 40, 3 (2010), 26–33.
  • (28) Dunkels, A., et al. The lwip tcp/ip stack. lwIP–A LightWeight TCP/IP Stack (2004).
  • (29) Edge, J. A generic hash table.
  • (30) Erman, J., Gopalakrishnan, V., Jana, R., and Ramakrishnan, K. K. Towards a spdy’ier mobile web? IEEE/ACM Transactions on Networking 23, 6 (2015), 2010–2023.
  • (31) Facebook. Aquila (internet deployment by drone).
  • (32) Facebook. Network connection class.
  • (33) Fastly. Advanced tcp optimizations.
  • (34) FCC. Measuring fixed broadband report - 2016.
  • (35) foundation, L. Open vSwitch.
  • (36) Gardner, J. R., Kusner, M. J., Xu, Z. E., Weinberger, K. Q., and Cunningham, J. P. Bayesian optimization with inequality constraints. In ICML (2014), pp. 937–945.
  • (37) Ghobadi, M., Yeganeh, S. H., and Ganjali, Y. Rethinking end-to-end congestion control in software-defined networks. In Proceedings of the 11th ACM Workshop on Hot Topics in networks (2012), ACM, pp. 61–66.
  • (38) Google. Quic, a multiplexed stream transport over udp.
  • (39) Guide, T. L. K. M. P. Character Device Drivers.
  • (40) Herodotou, H., Lim, H., Luo, G., Borisov, N., Dong, L., Cetin, F. B., and Babu, S. Starfish: A self-tuning system for big data analytics. In Cidr (2011), vol. 11, pp. 261–272.
  • (41) Hock, M., Bless, R., and Zitterbart, M. Experimental evaluation of bbr congestion control. In Network Protocols (ICNP), 2017 IEEE 25th International Conference on (2017), IEEE, pp. 1–10.
  • (42) Jay, N., Rotman, N. H., Godfrey, P., Schapira, M., and Tamar, A. Internet congestion control via deep reinforcement learning. arXiv preprint arXiv:1810.03259 (2018).
  • (43) Jeong, E., Woo, S., Jamshed, M. A., Jeong, H., Ihm, S., Han, D., and Park, K. mtcp: a highly scalable user-level tcp stack for multicore systems. In NSDI (2014), pp. 489–502.
  • (44) Jiang, J., Sekar, V., Milner, H., Shepherd, D., Stoica, I., and Zhang, H. Cfa: A practical prediction system for video qoe optimization. In NSDI (2016), pp. 137–150.
  • (45) Jiang, J., Sun, S., Sekar, V., and Zhang, H. Pytheas: Enabling data-driven quality of experience optimization using group-based exploration-exploitation. In 14th USENIX Symposium on Networked Systems Design and Implementation (NSDI 17) (Boston, MA, 2017), USENIX Association, pp. 393–406.
  • (46) Karlsson, J., and Kassler, A. Tcp performance in mobile ad hoc networks connected to the internet. REVISTA CIENTÍFICA PERIÓDICA-TELECOMUNICAÇÕES 10, 1 (2007), 22–29.
  • (47) Lee, Y., and Spring, N. Identifying and aggregating homogeneous ipv4 /24 blocks with hobbit. In Proceedings of the 2016 Internet Measurement Conference (New York, NY, USA, 2016), IMC ’16, ACM, pp. 151–165.
  • (48) Letham, B., Karrer, B., Ottoni, G., and Bakshy, E. Efficient tuning of online systems using Bayesian optimization.
  • (49) Levin, S. include/linux/hashtable.h.
  • (50) Li, W., Zhou, F., Chowdhury, K. R., and Meleis, W. M.

    Qtcp: Adaptive congestion control with reinforcement learning.

    IEEE Transactions on Network Science and Engineering (2018).
  • (51) Li, Z. L., Liang, M. C.-J., He, W., Zhu, L., Dai, W., Jiang, J., and Sun, G. Metis: Robustly tuning tail latencies of cloud systems. In ATC (USENIX Annual Technical Conference) (July 2018), USENIX.
  • (52) Liu, H. H., Viswanathan, R., Calder, M., Akella, A., Mahajan, R., Padhye, J., and Zhang, M. Efficiently delivering online services over integrated infrastructure. In NSDI (2016), vol. 1, p. 1.
  • (53) Loon, P. Balloon powered internet.
  • (54) Ltd., S. Speedchecker.
  • (55) Lu, D., Qiao, Y., Dinda, P. A., and Bustamante, F. E. Characterizing and predicting tcp throughput on the wide area network. In Distributed Computing Systems, 2005. ICDCS 2005. Proceedings. 25th IEEE International Conference on (2005), IEEE, pp. 414–424.
  • (56) Mao, H., Netravali, R., and Alizadeh, M. Neural adaptive video streaming with pensieve. In Proceedings of the Conference of the ACM Special Interest Group on Data Communication (2017), ACM, pp. 197–210.
  • (57) McKay, M. D., Beckman, R. J., and Conover, W. J. Comparison of three methods for selecting values of input variables in the analysis of output from a computer code. Technometrics 21, 2 (1979), 239–245.
  • (58) Mike Belshe, R. P. Spdy protocol.
  • (59) Mozilla. Network Information API, 2018.
  • (60) Mukerjee, M. K., Naylor, D., Jiang, J., Han, D., Seshan, S., and Zhang, H. Practical, real-time centralized control for cdn-based live video delivery. ACM SIGCOMM Computer Communication Review 45, 4 (2015), 311–324.
  • (61) Naseer, U., and Benson, T. Inspectorgadget: Inferring network protocol configuration for web services. In 2018 IEEE 38th International Conference on Distributed Computing Systems (ICDCS) (July 2018), pp. 1624–1629.
  • (62) Nejati, J., and Balasubramanian, A. An in-depth study of mobile browser performance. In Proceedings of the 25th International Conference on World Wide Web (2016), International World Wide Web Conferences Steering Committee, pp. 1305–1315.
  • (63) Netravali, R., Goyal, A., Mickens, J., and Balakrishnan, H. Polaris: Faster page loads using fine-grained dependency tracking. In 13th USENIX Symposium on Networked Systems Design and Implementation (NSDI 16) (2016), USENIX Association.
  • (64) Nie, X., Zhao, Y., Chen, G., Sui, K., Chen, Y., Pei, D., Zhang, M., and Zhang, J. Tcp wise: One initial congestion window is not enough. In Performance Computing and Communications Conference (IPCCC), 2017 IEEE 36th International (2017), IEEE, pp. 1–8.
  • (65) Nie, X., Zhao, Y., Pei, D., Chen, G., Sui, K., and Zhang, J. Reducing web latency through dynamically setting tcp initial window with reinforcement learning.
  • (66) of Sheffield, M. L. G. U. GPyOpt.
  • (67) Bing and google agree: Slow pages lose users.
  • (68) Pelikan, M., Goldberg, D. E., and Cantú-Paz, E. Boa: The bayesian optimization algorithm. In

    Proceedings of the 1st Annual Conference on Genetic and Evolutionary Computation-Volume 1

    (1999), Morgan Kaufmann Publishers Inc., pp. 525–532.
  • (69) Pi, Y., Jamin, S., Danzig, P., and Shaha, J. Ap-atoms: A high-accuracy data-driven client aggregation for global load balancing. IEEE/ACM Transactions on Networking 26, 6 (2018), 2748–2761.
  • (70) picoTCP. picotcp.
  • (71) Ruamviboonsuk, V., Netravali, R., Uluyol, M., and Madhyastha, H. V. Vroom: Accelerating the mobile web with server-aided dependency resolution. In Proceedings of the Conference of the ACM Special Interest Group on Data Communication (2017), ACM, pp. 390–403.
  • (72) Ruffy, F., Przystupa, M., and Beschastnikh, I. Iroko: A framework to prototype reinforcement learning for data center traffic control. arXiv preprint arXiv:1812.09975 (2018).
  • (73) Rüth, J., Bormann, C., and Hohlfeld, O. Large-scale scanning of tcp’s initial window. In Proceedings of the 2017 Internet Measurement Conference (2017), ACM, pp. 304–310.
  • (74) Rüth, J., Kunze, I., and Hohlfeld, O. An empirical view on content provider fairness. arXiv preprint arXiv:1905.07152 (2019).
  • (75) Schapira, M., and Winstein, K. Congestion-control throwdown. In Proceedings of the 16th ACM Workshop on Hot Topics in Networks (2017), ACM, pp. 122–128.
  • (76) scikit Decision Trees.
  • (77) Singh, S., Madhyastha, H. V., Krishnamurthy, S. V., and Govindan, R. Flexiweb: Network-aware compaction for accelerating mobile web transfers. In Proceedings of the 21st Annual International Conference on Mobile Computing and Networking (2015), ACM, pp. 604–616.
  • (78) Stein, M. Large sample properties of simulations using latin hypercube sampling. Technometrics 29, 2 (1987), 143–151.
  • (79) Sun, Y., Edmundson, A., Vanbever, L., Li, O., Rexford, J., Chiang, M., and Mittal, P. Raptor: Routing attacks on privacy in tor.
  • (80) Sun, Y., Yin, X., Jiang, J., Sekar, V., Lin, F., Wang, N., Liu, T., and Sinopoli, B. Cs2p: Improving video bitrate selection and adaptation with data-driven throughput prediction. In Proceedings of the 2016 ACM SIGCOMM Conference (2016), ACM, pp. 272–285.
  • (81) Sundaresan, S., Feamster, N., and Teixeira, R. Home network or access link? locating last-mile downstream throughput bottlenecks. In International Conference on Passive and Active Network Measurement (2016), Springer, pp. 111–123.
  • (82) Tran, V.-H., and Bonaventure, O. Beyond socket options: making the linux tcp stack truly extensible. arXiv preprint arXiv:1901.01863 (2019).
  • (83) Turkovic, B., Kuipers, F. A., and Uhlig, S. Interactions between congestion control algorithms. network 3, 17.
  • (84) Urvoy-Keller, G. On the stationarity of tcp bulk data transfers. In International Workshop on Passive and Active Network Measurement (2005), Springer, pp. 27–40.
  • (85) Van Aken, D., Pavlo, A., Gordon, G. J., and Zhang, B. Automatic database management system tuning through large-scale machine learning. In Proceedings of the 2017 ACM International Conference on Management of Data (2017), ACM, pp. 1009–1024.
  • (86) Wang, X. S., Balasubramanian, A., Krishnamurthy, A., and Wetherall, D. Demystifying page load performance with wprof. In NSDI (2013), pp. 473–485.
  • (87) Wang, X. S., Balasubramanian, A., Krishnamurthy, A., and Wetherall, D. How speedy is spdy? In NSDI (2014), pp. 387–399.
  • (88) Wang, X. S., Krishnamurthy, A., and Wetherall, D. Speeding up web page loads with shandian. In NSDI (2016), pp. 109–122.
  • (89) Winstein, K., and Balakrishnan, H. Tcp ex machina: computer-generated congestion control. In ACM SIGCOMM Computer Communication Review (2013), vol. 43, ACM, pp. 123–134.
  • (90) Yan, F. Y., Ma, J., Hill, G. D., Raghavan, D., Wahby, R. S., Levis, P., and Winstein, K. Pantheon: the training ground for internet congestion-control research. In 2018 USENIX Annual Technical Conference (USENIX ATC 18) (Boston, MA, 2018), USENIX Association, pp. 731–743.
  • (91) Yang, P., Shao, J., Luo, W., Xu, L., Deogun, J., and Lu, Y. Tcp congestion avoidance algorithm identification. IEEE/ACM Transactions on Networking (TON) 22, 4 (2014), 1311–1324.
  • (92) ZeroMQ. Zeromq.
  • (93) Zhang, Y., and Duffield, N. On the constancy of internet path properties. In Proceedings of the 1st ACM SIGCOMM Workshop on Internet Measurement (2001), ACM, pp. 197–211.
  • (94) Zhu, Y., Liu, J., Guo, M., Bao, Y., Ma, W., Liu, Z., Song, K., and Yang, Y. Bestconfig: tapping the performance potential of systems via automatic configuration tuning. In Proceedings of the 2017 Symposium on Cloud Computing (2017), ACM, pp. 338–350.