52 research outputs found
WiFi, LTE, or Both? Measuring Multi-Homed Wireless Internet Performance
No full textOver the past two or three years, wireless cellular networks have become faster than before, most notably due to the deployment of LTE, HSPA+, and other similar networks. LTE throughputs can reach many megabits per second and can even rival WiFi throughputs in some locations. This paper addresses a fundamental question confronting transport and application-layer protocol designers: which network should an application use? WiFi, LTE, or Multi-Path TCP (MPTCP) running over both?
We compare LTE and WiFi for transfers of different sizes along both directions (i.e. the uplink and the downlink) using a crowd-sourced mobile application run by 750 users over 180 days in 16 different countries. We find that LTE outperforms WiFi 40\% of the time, which is a higher fraction than one might expect at first sight.
We measure flow-level MPTCP performance and compare it with the performance of TCP running over exclusively WiFi or LTE in 20 different locations across 7 cities in the United States. For short flows, we find that MPTCP performs worse than regular TCP running over the faster link; further, selecting the correct network for the primary subflow in MPTCP is critical in achieving good performance. For long flows, however, selecting the proper MPTCP congestion control algorithm is equally important.
To complement our flow-level analysis, we analyze the traffic patterns of several mobile apps, finding that apps can be categorized as "short-flow dominated" or "long-flow dominated". We then record and replay these patterns over emulated WiFi and LTE links. We find that application performance has a similar dependence on the choice of networks as flow-level performance: an application dominated by short flows sees little gain from MPTCP, while an application with longer flows can benefit much more from MPTCP --- if the application can pick the right network for the primary subflow and the right choice of MPTCP congestion control.National Science Foundation (U.S.) (Grant 1407470)National Science Foundation (U.S.) (Grant 1161964
Recommended from our members
Alohamora: Reviving HTTP/2 Push and Preload by Adapting Policies On-the-Fly
No full textDespite their promise of improved performance, HTTP/2's server push and link preload features have seen minimal adoption, largely because designing performant push/preload policies requires complex reasoning about the subtle relationships between page content, browser state, device resources, and network conditions. Static policies and guidelines that sufficiently generalize across these diverse conditions remain elusive.We present Alohamora, a system that automatically generates push/preload policies using Reinforcement Learning (RL). Alohamora trains a neural network that, given inputs that characterize the page structure and execution environment, outputs a push/preload policy for the page load at hand. To ensure efficient and practical training despite the large space of potential policies, number of pages served by a given site, and high mobile page load times, Alohamora introduces several key innovations: a faithful page load simulator that can evaluate a policy in several milliseconds (compared to 10s of seconds for a regular page load), and a page clustering strategy that appropriately balances insights for push/preload with the number of pages required during training. Experiments across a wide range of pages and mobile execution environments reveal that Alohamora is able to accelerate page loads by 19-57% and 12-34% for page load time and Speed Index, respectively
Speaking Browser: On Patterns in Web Browsing History and the Efficacy of Seq2Seq Models for Access Prediction
No full textThis thesis investigates a dataset of 11 months of my personal browsing history. It tests the viability of LSTM and transformer-based models for predicting the websites a user will access next given their browsing history. The approach divides browser history entries into browsing session URL groups that are further divided into source and target URL sequences. Embeddings are learned for unique page URLs and, in one trial, month-time slots. Exploration of the dataset suggests some predictability, but while models show promise in learning training data, they fail to predict future accesses for most held-out testing data. Successful predictions generated from test data often include the most frequently and consistently accessed pages, like Gmail
Understanding and improving Web page load times on modern networks
No full textThesis: S.M., Massachusetts Institute of Technology, Department of Electrical Engineering and Computer Science, 2015.This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.Cataloged from student-submitted PDF version of thesis.Includes bibliographical references (pages 77-80).This thesis first presents a measurement toolkit, Mahimahi, that records websites and replays them under emulated network conditions. Mahimahi improves on prior record-and-replay frameworks by emulating the multi-origin nature of Web pages, isolating its network traffic, and enabling evaluations of a larger set of target applications beyond browsers. Using Mahimahi, we perform a case study comparing current multiplexing protocols, HTTP/1.1 and SPDY, and a protocol in development, QUIC, to a hypothetical optimal protocol. We find that all three protocols are significantly suboptimal and their gaps from the optimal only increase with higher link speeds and RTTs. The reason for these trends is the same for each protocol: inherent source-level dependencies between objects on a Web page and browser limits on the number of parallel flows lead to serialized HTTP requests and prevent links from being fully occupied. To mitigate the effect of these dependencies, we built Cumulus, a user-deployable combination of a content-distribution network and a cloud browser that improves page load times when the user is at a significant delay from a Web page's servers. Cumulus contains a "Mini-CDN"-a transparent proxy running on the user's machine-and a "Puppet": a headless browser run by the user on a well-connected public cloud. When the user loads a Web page, the Mini-CDN forwards the user's request to the Puppet, which loads the entire page and pushes all of the page's objects to the Mini-CDN, which caches them locally. Cumulus benefits from the finding that dependency resolution, the process of learning which objects make up a Web page, accounts for a considerable amount of user-perceived wait time. By moving this task to the Puppet, Cumulus can accelerate page loads without modifying existing Web browsers or servers. We find that on cellular, in-flight Wi-Fi, and transcontinental networks, Cumulus accelerated the page loads of Google's Chrome browser by 1.13-2.36×. Performance was 1.19-2.13× faster than Opera Turbo, and 0.99-1.66× faster than Chrome with Google's Data Compression Proxy.by Ravi Arun Netravali.S.M
Recommended from our members
Bridging the Gap Between Application Logic and Auto-optimization in Modern Data Analytics
No full textRecent decades have seen an explosion in the diversity and scale of data analytics tasks. While data analysis of the late 20th century was characterized by the dominance of relational databases and highly structured querying languages, demand for less structured and more complex tasks has resulted in new data analytics frameworks that break with the norms of historical systems. This growth has come at the cost of breaking with the assumptions that guided automated optimization in historical systems. Automated optimizations analyze the input program of a system and extract insights that allow the system to better execute a given task with little to no human effort. Absent these features, analysts must manually tune data processing frameworks to achieve reasonable performance, a delicate and time-consuming endeavor.In this thesis, I argue that automated optimization techniques, such as caching and physical design, that have long been deployed in relational frameworks remain both relevant and necessary to achieving sustainable performance in modern systems. Via two projects, each targeting a different class of analysis tasks, I identify new techniques to bridge the gap between modern data analytics frameworks and established automated optimization techniques
Recommended from our members
Towards Cloud-Scale Debugging
No full textCloud computing is an integral part of today's world: it primarily enables individuals and enterprises to provision and manage resources such as compute, storage, etc., for their needs with the click of a button. Modular approach to software development enabled cloud providers to rapidly evolve and deliver increasing number of services to users rendering clouds mission-critical. To insure prompt serviceability of this Achilles’ Heel from facing incidents, cloud providers employ significant human resources. However, with the ever increasing number of services offered by clouds and growing types of workloads such as the proliferation of Machine Learning workloads in recent times, it is no longer viable for cloud providers to scale their human resources at this pace to insure prompt serviceability of their clouds.In this dissertation, I present my work towards improving the serviceability of clouds by leveraging insights from my experience with real debugging workflows employed at the three largest clouds today. I present techniques from Machine Learning and Natural Language Processing to leverage the vast amount of historical debugging data in clouds to develop tools that provide assistance to their engineers. I present a 'Coarsening' framework that enables transition towards a centralized debugging plane and discuss practical evaluations of tools built using this framework.I present Revelio, a tool that can generate debugging queries for engineers to execute over system-wide logged data, whose results can likely hint them of the root cause of an incident. To enable benchmarking many techniques, I also built a distributed systems debugging testbed that can inject faults into services, interface with human users and collect execution logs across the system. I present AutoARTS, a tool that can tag a lengthy postmortem report of an incident in the cloud with all root causes from an extensive taxonomy and can also highlight key pieces of information from a postmortem for ease of analysis. I present PerfRCA, a tool that can scale causal discovery to production-scale telemetry to reason performance degradations. I conclude with my vision for a centralized approach to automatically extract generalizable debugging assistance to engineers across a cloud
Recommended from our members
Leveraging Distributed Tracing and Container Cloning for Replay Debugging of Microservices
No full textMicroservice architectures have gained prominence in recent years for building large-scale industrial distributed systems. However, microservice architectures make the usage of replay debugging, a powerful technique for finding root causes of faults, very challenging because of the polyglot (written in several languages) services, large accumulated state of services, and tight latency limits imposed by long hop-chains. This work attempts to provide a framework for enabling replay debugging in production microservice applications. We study 25 real-world faults in microservice systems collected from diverse sources, categorize these faults by fault symptoms, and create 15 application agnostic mutation operators for microservices. We then propose a language agnostic replay debugging framework for microservice applications that uses a distributed tracing system to record network requests and enables replay of those requests on cloned service containers running in a debug environment. A key component of this framework is an anomaly detector that uses span-level and container-level monitoring to detect fault symptoms found in our study and localizes faults to trace level so that faulty traces can be easily replayed to find the root cause. An open-source microservices application injected successively with the mutation operators is used for an evaluation that shows that our framework is upto an order of magnitude lighter-weight than language-specific recording tools such as Chrome DevTools or VisualVM and can help in finding root causes of 9 out of 15 mutations at a line or function level
Mahimahi: A Lightweight Toolkit for Reproducible Web Measurement
No full textThis demo presents a measurement toolkit, Mahimahi, that records websites and replays them under emulated network conditions. Mahimahi is structured as a set of arbitrarily composable UNIX shells. It includes two shells to record and replay Web pages, RecordShell and ReplayShell, as well as two shells for network emulation, DelayShell and LinkShell. In addition, Mahimahi includes a corpus of recorded websites along with benchmark results and link traces (https://github.com/ravinet/sites).
Mahimahi improves on prior record-and-replay frameworks in three ways. First, it preserves the multi-origin nature of Web pages, present in approximately 98% of the Alexa U.S. Top 500, when replaying. Second, Mahimahi isolates its own network traffic, allowing multiple instances to run concurrently with no impact on the host machine and collected measurements. Finally, Mahimahi is not inherently tied to browsers and can be used to evaluate many different applications.
A demo of Mahimahi recording and replaying a Web page over an emulated link can be found at http://youtu.be/vytwDKBA-8s. The source code and instructions to use Mahimahi are available at http://mahimahi.mit.edu/
Improving web applications with fine-grained data flows
No full textThesis: Ph. D., Massachusetts Institute of Technology, Department of Electrical Engineering and Computer Science, 2018.Cataloged from PDF version of thesis.Includes bibliographical references (pages 131-144).Web applications have significantly increased in complexity over the past several decades to support the wide range of services and performance requirements that users have come to expect. On the client-side, browsers are multi-process systems that can handle numerous content formats, rich interactivity, and asynchronous 10 patterns. On the server-side, applications are distributed across many machines and employ multi-tier architectures to implement application logic, caching, and persistent storage. As a result, web applications have become complex distributed systems that are difficult to understand, debug, and optimize. This dissertation presents fine-grained data flows as a new mechanism for understanding and optimizing complex web applications. Fine-grained data flows comprise the set of low-level reads and writes made to distributed application state during execution. We explain how fine-grained data flows can be tracked efficiently in production systems. We then present four concrete systems that illustrate how fine-grained data flows enable powerful performance optimizations and debugging primitives. Polaris dynamically reorders client HTTP requests during a page load to maximally overlap network round trips without violating data flow dependencies, reducing page load times by 34% (1.3 seconds). Prophecy uses data flow logs to create a snapshot of a mobile page's post-load state, which clients can process to elide intermediate computations, reducing bandwidth consumption by 21%, energy usage by 36%, and load times by 53% (2.8 seconds). Vesper is the first system to accurately and automatically measure page time-to-interactivity, without using heuristics or developer annotations. Vesper determines a page's interactive state by firing event handlers and analyzing the resulting data flows. Vesper-guided optimizations improve time- to- interactivity by 32%, generating more satisfaction in user studies than systems targeting past metrics. Cascade is the first replay debugger to support distributed, fine-grained provenance tracking. Cascade also enables speculative bug fix analysis, i.e., replaying a program to a point, changing program state, and resuming replay, using data flow tracking and causal analysis to evaluate potential bug fixes.by Ravi Arun Netravali.Ph. D
Recommended from our members
Making Video Analytics Applications Efficient and Affordable
No full textWhile using machine learning to analyze video data is seeing explosive growth, modern vision models are difficult and expensive to deploy in practice. This is because while models are getting more accurate and robust, they are also getting more complicated and thus more resource-intensive. At the same time, the environments in which they are used, such as self-driving cars, demand extremely fast and accurate results.Traditionally, all video data was sent to cloud servers, where models were run over the frames on GPU machines. Recently though, the use of edge computing has shown promise in addressing this tension between performance and resource usage. Resources available at the edge are highly heterogeneous in terms of computational power and memory, and while most prior work assumes a well-equipped edge, we find that the devices used in practice are often inexpensive commodity hardware. This limits the amount of computation that can practically happen at the edge.In this thesis, we aim to make the most of these resource-constrained edge devices. We present two systems that improve the tradeoff between performance and resource usage in live video analysis. Our first system, Reducto, uses the limited amount of compute available on smart cameras to run cheap computer vision techniques and filter out frames that are similar enough to the previous frame that we can reuse the previously computed result as an approximation. This lowers GPU usage by over 50% and doubles processing speed. Our next system, GEMEL, addresses the memory bottleneck of running many models on an edge server by finding and merging common layers across a diverse set of models. This lowers the memory footprint by up to 60% and improves accuracy by up to 39%
- …
