@inproceedings{10.1145/3190508.3190516,
author = {Qu, Hang and Mashayekhi, Omid and Shah, Chinmayee and Levis, Philip},
title = {Decoupling the control plane from program control flow for flexibility and performance in cloud computing},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190516},
doi = {10.1145/3190508.3190516},
abstract = {Existing cloud computing control planes do not scale to more than a few hundred cores, while frameworks without control planes scale but take seconds to reschedule a job. We propose an asynchronous control plane for cloud computing systems, in which a central controller can dynamically reschedule jobs but worker nodes never block on communication with the controller. By decoupling control plane traffic from program control flow in this way, an asynchronous control plane can scale to run millions of computations per second while being able to reschedule computations within milliseconds.We show that an asynchronous control plane can match the scalability and performance of TensorFlow and MPI-based programs while rescheduling individual tasks in milliseconds. Scheduling an individual task takes 1μs, such that a 1,152 core cluster can schedule over 120 million tasks/second and this scales linearly with the number of cores. The ability to schedule huge numbers of tasks allows jobs to be divided into very large numbers of tiny tasks, whose improved load balancing can speed up computations 2.1--2.3X.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {1},
numpages = {13},
keywords = {centralized control, cloud framework control planes, distributed scheduling},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190515,
author = {Park, Jun Woo and Tumanov, Alexey and Jiang, Angela and Kozuch, Michael A. and Ganger, Gregory R.},
title = {3Sigma: distribution-based cluster scheduling for runtime uncertainty},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190515},
doi = {10.1145/3190508.3190515},
abstract = {The 3Sigma cluster scheduling system uses job runtime histories in a new way. Knowing how long each job will execute enables a scheduler to more effectively pack jobs with diverse time concerns (e.g., deadline vs. the-sooner-the-better) and placement preferences on heterogeneous cluster resources. But, existing schedulers use single-point estimates (e.g., mean or median of a relevant subset of historical runtimes), and we show that they are fragile in the face of real-world estimate error profiles. In particular, analysis of job traces from three different large-scale cluster environments shows that, while the runtimes of many jobs can be predicted well, even state-of-the-art predictors have wide error profiles with 8--23\% of predictions off by a factor of two or more. Instead of reducing relevant history to a single point, 3Sigma schedules jobs based on full distributions of relevant runtime histories and explicitly creates plans that mitigate the effects of anticipated runtime uncertainty. Experiments with workloads derived from the same traces show that 3Sigma greatly outperforms a state-of-the-art scheduler that uses point estimates from a state-of-the-art predictor; in fact, the performance of 3Sigma approaches the end-to-end performance of a scheduler based on a hypothetical, perfect runtime predictor. 3Sigma reduces SLO miss rate, increases cluster goodput, and improves or matches latency for best effort jobs.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {2},
numpages = {17},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190517,
author = {Peng, Yanghua and Bao, Yixin and Chen, Yangrui and Wu, Chuan and Guo, Chuanxiong},
title = {Optimus: an efficient dynamic resource scheduler for deep learning clusters},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190517},
doi = {10.1145/3190508.3190517},
abstract = {Deep learning workloads are common in today's production clusters due to the proliferation of deep learning driven AI services (e.g., speech recognition, machine translation). A deep learning training job is resource-intensive and time-consuming. Efficient resource scheduling is the key to the maximal performance of a deep learning cluster. Existing cluster schedulers are largely not tailored to deep learning jobs, and typically specifying a fixed amount of resources for each job, prohibiting high resource efficiency and job performance. This paper proposes Optimus, a customized job scheduler for deep learning clusters, which minimizes job training time based on online resource-performance models. Optimus uses online fitting to predict model convergence during training, and sets up performance models to accurately estimate training speed as a function of allocated resources in each job. Based on the models, a simple yet effective method is designed and used for dynamically allocating resources and placing deep learning tasks to minimize job completion time. We implement Optimus on top of Kubernetes, a cluster manager for container orchestration, and experiment on a deep learning cluster with 7 CPU servers and 6 GPU servers, running 9 training jobs using the MXNet framework. Results show that Optimus outperforms representative cluster schedulers by about 139\% and 63\% in terms of job completion time and makespan, respectively.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {3},
numpages = {14},
keywords = {deep learning, resource management},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190549,
author = {Garefalakis, Panagiotis and Karanasos, Konstantinos and Pietzuch, Peter and Suresh, Arun and Rao, Sriram},
title = {Medea: scheduling of long running applications in shared production clusters},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190549},
doi = {10.1145/3190508.3190549},
abstract = {The rise in popularity of machine learning, streaming, and latency-sensitive online applications in shared production clusters has raised new challenges for cluster schedulers. To optimize their performance and resilience, these applications require precise control of their placements, by means of complex constraints, e.g., to collocate or separate their long-running containers across groups of nodes. In the presence of these applications, the cluster scheduler must attain global optimization objectives, such as maximizing the number of deployed applications or minimizing the violated constraints and the resource fragmentation, but without affecting the scheduling latency of short-running containers.We present Medea, a new cluster scheduler designed for the placement of long- and short-running containers. Medea introduces powerful placement constraints with formal semantics to capture interactions among containers within and across applications. It follows a novel two-scheduler design: (i) for long-running containers, it applies an optimization-based approach that accounts for constraints and global objectives; (ii) for short-running containers, it uses a traditional task-based scheduler for low placement latency. Evaluated on a 400-node cluster, our implementation of Medea on Apache Hadoop YARN achieves placement of long-running applications with significant performance and resilience benefits compared to state-of-the-art schedulers.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {4},
numpages = {13},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190513,
author = {Satish, Arjun and Shiou, Thomas and Zhang, Chuck and Elmeleegy, Khaled and Zwaenepoel, Willy},
title = {Scrub: online troubleshooting for large mission-critical applications},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190513},
doi = {10.1145/3190508.3190513},
abstract = {Scrub is a troubleshooting tool for distributed applications that operate under strict SLOs common in production environments. It allows users to formulate queries on events occurring during execution in order to assess the correctness of the application's operation.Scrub has been in use for two years at Turn, where developers and users have relied on it to resolve numerous issues in its online advertisement bidding platform. This platform spans thousands of machines across the globe, serving several million bid requests per second, and dispensing many millions of dollars in advertising budgets.Troubleshooting distributed applications is notoriously hard, and its difficulty is exacerbated by the presence of strict SLOs, which requires the troubleshooting tool to have only minimal impact on the hosts running the application. Furthermore, with large amounts of money at stake, users expect to be able to run frequent diagnostics and demand quick evaluation and remediation of any problems. These constraints have led to a number of design and implementation decisions, that go counter to conventional wisdom. In particular, Scrub supports only a restricted form of joins. Its query execution strategy eschews imposing any overhead on the application hosts. In particular, joins, group-by operations and aggregations are sent to a dedicated centralized facility. In terms of implementation, Scrub avoids the overhead and security concerns of dynamic instrumentation. Finally, at all levels of the system, accuracy is traded for minimal impact on the hosts.We present the design and implementation of Scrub and contrast its choices to those made in earlier systems. We illustrate its power by describing a number of use cases, and we demonstrate its negligible overhead on the underlying application. On average, we observe a maximum CPU overhead of up to 2.5\% on application hosts and a 1\% increase in request latency. These overheads allow the advertisement bidding platform to operate well within its SLOs.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {5},
numpages = {15},
keywords = {advertising, big data, debugging, distributed systems, mission critical, query processing, scrub, troubleshooting},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190525,
author = {Brocanelli, Marco and Wang, Xiaorui},
title = {Hang doctor: runtime detection and diagnosis of soft hangs for smartphone apps},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190525},
doi = {10.1145/3190508.3190525},
abstract = {A critical quality factor for smartphone apps is responsiveness, which indicates how fast an app reacts to user actions. A soft hang occurs when the app's response time of handling a certain user action is longer than a user-perceivable delay. Soft hangs can be caused by normal User Interface (UI) rendering or some blocking operations that should not be conducted on the app's main thread (i.e., soft hang bugs). Existing solutions on soft hang bug detection focus mainly on offline app code examination to find previously known blocking operations and then move them off the main thread. Unfortunately, such offline solutions can fail to identify blocking operations that are previously unknown or hidden in libraries.In this paper, we present Hang Doctor, a runtime methodology that supplements the existing offline algorithms by detecting and diagnosing soft hangs caused by previously unknown blocking operations. Hang Doctor features a two-phase algorithm that first checks response time and performance event counters for detecting possible soft hang bugs with small overheads, and then performs stack trace analysis when diagnosis is necessary. A novel soft hang filter based on correlation analysis is designed to minimize false positives and negatives for high detection performance and low overhead. We have implemented a prototype of Hang Doctor and tested it with the latest releases of 114 real-world apps. Hang Doctor has identified 34 new soft hang bugs that are previously unknown to their developers, among which 62\%, so far, have been confirmed by the developers, and 68\% are missed by offline algorithms.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {6},
numpages = {15},
keywords = {mobile apps, performance counters, soft hang bug},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190552,
author = {Li, Jiaxin and Chen, Yuxi and Liu, Haopeng and Lu, Shan and Zhang, Yiming and Gunawi, Haryadi S. and Gu, Xiaohui and Lu, Xicheng and Li, Dongsheng},
title = {Pcatch: automatically detecting performance cascading bugs in cloud systems},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190552},
doi = {10.1145/3190508.3190552},
abstract = {Distributed systems have become the backbone of modern clouds. Users often expect high scalability and performance isolation from distributed systems. Unfortunately, a type of poor software design, which we refer to as performance cascading bugs (PCbugs), can often cause the slowdown of non-scalable code in one job to propagate, causing global performance degradation and even threatening system availability.This paper presents a tool, PCatch, that can automatically predict PCbugs by analyzing system execution under small-scale workloads. PCatch contains three key components in predicting PCbugs. It uses program analysis to identify code regions whose execution time can potentially increase dramatically with the workload size; it adapts the traditional happens-before model to reason about software resource contention and performance dependency relationship; it uses dynamic tracking to identify whether the slowdown propagation is contained in one job or not. Our evaluation using representative distributed systems, Cassandra, Hadoop MapReduce, HBase, and HDFS, shows that PCatch can accurately predict PCbugs based on small-scale workload execution.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {7},
numpages = {14},
keywords = {bug detection, cascading problems, cloud computing, distributed systems, performance bugs},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190526,
author = {Mace, Jonathan and Fonseca, Rodrigo},
title = {Universal context propagation for distributed system instrumentation},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190526},
doi = {10.1145/3190508.3190526},
abstract = {Many tools for analyzing distributed systems propagate contexts along the execution paths of requests, tasks, and jobs, in order to correlate events across process, component and machine boundaries. There is a wide range of existing and proposed uses for these tools, which we call cross-cutting tools, such as tracing, debugging, taint propagation, provenance, auditing, and resource management, but few of them get deployed pervasively in large systems. When they do, they are brittle, hard to evolve, and cannot coexist with each other. While they use very different context metadata, the way they propagate the information alongside execution is the same. Nevertheless, in existing tools, these aspects are deeply intertwined, causing most of these problems.In this paper, we propose a layered architecture for cross-cutting tools that separates concerns of system developers and tool developers, enabling independent instrumentation of systems, and the deployment and evolution of multiple such tools. At the heart of this layering is a general underlying format, baggage contexts, that enables the complete decoupling of system instrumentation for context propagation from tool logic. Baggage contexts make propagation opaque and general, while still maintaining correctness of the metadata under arbitrary concurrency and different data types. We demonstrate the practicality of the architecture with implementations in Java and Go, porting of several existing cross-cutting tools, and instrumenting existing distributed systems with all of them.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {8},
numpages = {18},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190531,
author = {Li, Yiran and Wei, Da and Chen, Xiaoqi and Song, Ziheng and Wu, Ruihan and Li, Yuxing and Jin, Xin and Xu, Wei},
title = {DumbNet: a smart data center network fabric with dumb switches},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190531},
doi = {10.1145/3190508.3190531},
abstract = {Today's data center networks have already pushed many functions to hosts. A fundamental question is how to divide functions between network and software. We present DumbNet, a new data center network architecture with no state in switches. DumbNet switches have no forwarding tables, no state, and thus require no configurations. Almost all control plane functions are pushed to hosts: they determine the entire path of a packet and then write the path as tags in the packet header. Switches only need to examine the tags to forward packets and monitor the port state. We design a set of host-based mechanisms to make the new architecture viable, from network bootstrapping and topology maintenance to network routing and failure handling. We build a prototype with 7 switches and 27 servers, as well as an FPGA-based switch. Extensive evaluations show that DumbNet achieves performance comparable to traditional networks, supports application-specific extensions like flowlet-based traffic engineering, and stays extremely simple and easy-to-manage.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {9},
numpages = {13},
keywords = {data center networks},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190519,
author = {Zhang, Yuchao and Jiang, Junchen and Xu, Ke and Nie, Xiaohui and Reed, Martin J. and Wang, Haiyang and Yao, Guang and Zhang, Miao and Chen, Kai},
title = {BDS: a centralized near-optimal overlay network for inter-datacenter data replication},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190519},
doi = {10.1145/3190508.3190519},
abstract = {Many important cloud services require replicating massive data from one datacenter (DC) to multiple DCs. While the performance of pair-wise inter-DC data transfers has been much improved, prior solutions are insufficient to optimize bulk-data multicast, as they fail to explore the capability of servers to store-and-forward data, as well as the rich inter-DC overlay paths that exist in geo-distributed DCs. To take advantage of these opportunities, we present BDS, an application-level multicast overlay network for large-scale inter-DC data replication. At the core of BDS is a fully centralized architecture, allowing a central controller to maintain an up-to-date global view of data delivery status of intermediate servers, in order to fully utilize the available overlay paths. To quickly react to network dynamics and workload churns, BDS speeds up the control algorithm by decoupling it into selection of overlay paths and scheduling of data transfers, each can be optimized efficiently. This enables BDS to update overlay routing decisions in near realtime (e.g., every other second) at the scale of multicasting hundreds of TB data over tens of thousands of overlay paths. A pilot deployment in one of the largest online service providers shows that BDS can achieve 3-5 x speedup over the provider's existing system and several well-known overlay routing baselines.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {10},
numpages = {14},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190558,
author = {Sonchack, John and Aviv, Adam J. and Keller, Eric and Smith, Jonathan M.},
title = {Turboflow: information rich flow record generation on commodity switches},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190558},
doi = {10.1145/3190508.3190558},
abstract = {Fine-grained traffic flow records enable many powerful applications, especially in combination with telemetry systems that supports high coverage, i.e., of every link and at all times. Current solutions, however, make undesirable trade-offs between infrastructure cost and information richness. Switches that generate flow records, e.g., NetFlow switches, are a low cost solution but current designs sacrifice information richness, e.g., by sampling. Information rich alternatives rely heavily on servers, which increases cost to the point that they are impractical for high coverage. In this paper, we present the design, implementation, and evaluation of TurboFlow, a flow record generator for programmable switches that does not compromise on either cost or information richness. TurboFlow produces fine- grained and unsampled flow records with custom features entirely at the switch without relying on any support from external servers. This is a challenge given high traffic rates and the limitations of switch hardware. To overcome, we decompose the flow record generation algorithm and optimize it for the heterogeneous processors in programmable switches. We show that with this design, TurboFlow can support multi-terabit workloads on readily available commodity switches to enable information rich monitoring with high coverage.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {11},
numpages = {16},
keywords = {P4, netflow, network monitoring, programmable switch hardware},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190528,
author = {Hung, Chien-Chun and Ananthanarayanan, Ganesh and Golubchik, Leana and Yu, Minlan and Zhang, Mingyang},
title = {Wide-area analytics with multiple resources},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190528},
doi = {10.1145/3190508.3190528},
abstract = {Running data-parallel jobs across geo-distributed sites has emerged as a promising direction due to the growing need for geo-distributed cluster deployment. A key difference between geo-distributed and intra-cluster jobs is the heterogeneous (and often constrained) nature of compute and network resources across the sites. We propose Tetrium, a system for multi-resource allocation in geo-distributed clusters, that jointly considers both compute and network resources for task placement and job scheduling. Tetrium significantly reduces job response time, while incorporating several other performance goals with simple control knobs. Our EC2 deployment and trace-driven simulations suggest that Tetrium improves the average job response time by up to 78\% compared to existing data-locality-based solutions, and up to 55\% compared to Iridium, the recently proposed geo-distributed analytics system.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {12},
numpages = {16},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190511,
author = {Xiang, Yaocheng and Wang, Xiaolin and Huang, Zihui and Wang, Zeyu and Luo, Yingwei and Wang, Zhenlin},
title = {DCAPS: dynamic cache allocation with partial sharing},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190511},
doi = {10.1145/3190508.3190511},
abstract = {In a multicore system, effective management of shared last level cache (LLC), such as hardware/software cache partitioning, has attracted significant research attention. Some eminent progress is that Intel introduced Cache Allocation Technology (CAT) to its commodity processors recently. CAT implements way partitioning and provides software interface to control cache allocation. Unfortunately, CAT can only allocate at way level, which does not scale well for a large thread or program count to serve their various performance goals effectively. This paper proposes Dynamic Cache Allocation with Partial Sharing (DCAPS), a framework that dynamically monitors and predicts a multi-programmed workload's cache demand, and reallocates LLC given a performance target. Further, DCAPS explores partial sharing of a cache partition among programs and thus practically achieves cache allocation at a finer granularity. DCAPS consists of three parts: (1) Online Practical Miss Rate Curve (OPMRC), a low-overhead software technique to predict online miss rate curves (MRCs) of individual programs of a workload; (2) a prediction model that estimates the LLC occupancy of each individual program under any CAT allocation scheme; (3) a simulated annealing algorithm that searches for a near-optimal CAT scheme given a specific performance goal. Our experimental results show that DCAPS is able to optimize for a wide range of performance targets and can scale to a large core count.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {13},
numpages = {15},
keywords = {cache allocation technology, cache occupancy, cache partitioning, miss rate curve, multi-core architectures},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190555,
author = {Xu, Cong and Rajamani, Karthick and Ferreira, Alexandre and Felter, Wesley and Rubio, Juan and Li, Yang},
title = {dCat: dynamic cache management for efficient, performance-sensitive infrastructure-as-a-service},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190555},
doi = {10.1145/3190508.3190555},
abstract = {In the modern multi-tenant cloud, resource sharing increases utilization but causes performance interference between tenants. More generally, performance isolation is also relevant in any multi-workload scenario involving shared resources. Last level cache (LLC) on processors is shared by all CPU cores in x86, thus the cloud tenants inevitably suffer from the cache flush by their noisy neighbors running on the same socket. Intel Cache Allocation Technology (CAT) provides a mechanism to assign cache ways to cores to enable cache isolation, but its static configuration can result in underutilized cache when a workload cannot benefit from its allocated cache capacity, and/or lead to sub-optimal performance for workloads that do not have enough assigned capacity to fit their working set.In this work, we propose a new dynamic cache management technology (dCat) to provide strong cache isolation with better performance. For each workload, we target a consistent, minimum performance bound irrespective of others on the socket and dependent only on its rightful share of the LLC capacity. In addition, when there is spare capacity on the socket, or when some workloads are not obtaining beneficial performance from their cache allocation, dCat dynamically reallocates cache space to cache-intensive workloads. We have implemented dCat in Linux on top of CAT to dynamically adjust cache mappings. dCat requires no modifications to applications so that it can be applied to all cloud workloads. Based on our evaluation, we see an average of 25\% improvement over shared cache and 15.7\% over static CAT for selected, memory intensive, SPEC CPU2006 workloads. For typical cloud workloads, with Redis we see 57.6\% improvement (over shared LLC) and 26.6\% improvement (over static partition) and with ElasticSearch we see 11.9\% improvement over both.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {14},
numpages = {13},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190544,
author = {Zhang, Jie and Jung, Myoungsoo},
title = {Flashabacus: a self-governing flash-based accelerator for low-power systems},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190544},
doi = {10.1145/3190508.3190544},
abstract = {Energy efficiency and computing flexibility are some of the primary design constraints of heterogeneous computing. In this paper, we present FlashAbacus, a data-processing accelerator that self-governs heterogeneous kernel executions and data storage accesses by integrating many flash modules in lightweight multiprocessors. The proposed accelerator can simultaneously process data from different applications with diverse types of operational functions, and it allows multiple kernels to directly access flash without the assistance of a host-level file system or an I/O runtime library. We prototype FlashAbacus on a multicore-based PCIe platform that connects to FPGA-based flash controllers with a 20 nm node process. The evaluation results show that FlashAbacus can improve the bandwidth of data processing by 127\%, while reducing energy consumption by 78.4\%, as compared to a conventional method of heterogeneous computing.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {15},
numpages = {15},
keywords = {NAND flash, accelerator, data-processing, heterogeneous computing},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190537,
author = {Nitu, Vlad and Teabe, Boris and Tchana, Alain and Isci, Canturk and Hagimont, Daniel},
title = {Welcome to zombieland: practical and energy-efficient memory disaggregation in a datacenter},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190537},
doi = {10.1145/3190508.3190537},
abstract = {In this paper, we propose an effortless way for disaggregating the CPU-memory couple, two of the most important resources in cloud computing. Instead of redesigning each resource board, the disaggregation is done at the power supply domain level. In other words, CPU and memory still share the same board, but their power supply domains are separated. Besides this disaggregation, we make the two following contributions: (1) the prototyping of a new ACPI sleep state (called zombie and noted Sz) which allows to suspend a server (thus save energy) while making its memory remotely accessible; and (2) the prototyping of a rack-level system software which allows the transparent utilization of the entire rack resources (avoiding resource waste). We experimentally evaluate the effectiveness of our solution and show that it can improve the energy efficiency of state-of-the-art consolidation techniques by up to 86\%, with minimal additional complexity.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {16},
numpages = {12},
keywords = {energy efficiency, memory disaggregation, virtualization},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190514,
author = {Psaroudakis, Iraklis and Kaestle, Stefan and Grimmer, Matthias and Goodman, Daniel and Lozi, Jean-Pierre and Harris, Tim},
title = {Analytics with smart arrays: adaptive and efficient language-independent data},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190514},
doi = {10.1145/3190508.3190514},
abstract = {This paper introduces smart arrays, an abstraction for providing adaptive and efficient language-independent data storage. Their smart functionalities include NUMA-aware data placement across sockets and bit compression. We show how our single C++ implementation can be used efficiently from both native C++ and compiled Java code. We experimentally evaluate smart arrays on a diverse set of C++ and Java analytics workloads. Further, we show how their smart functionalities affect performance and lead to differences in hardware resource demands on multicore machines, motivating the need for adaptivity. We observe that smart arrays can significantly decrease the memory space requirements of analytics workloads, and improve their performance by up to 4x. Smart arrays are the first step towards general smart collections with various smart functionalities that enable the consumption of hardware resources to be traded-off against one another.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {17},
numpages = {15},
keywords = {NUMA, adaptivity, compression, data structures, graph analytics, language interoperability, multicore, resource trade-offs},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190551,
author = {Yu, Yuan and Abadi, Mart\'{\i}n and Barham, Paul and Brevdo, Eugene and Burrows, Mike and Davis, Andy and Dean, Jeff and Ghemawat, Sanjay and Harley, Tim and Hawkins, Peter and Isard, Michael and Kudlur, Manjunath and Monga, Rajat and Murray, Derek and Zheng, Xiaoqiang},
title = {Dynamic control flow in large-scale machine learning},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190551},
doi = {10.1145/3190508.3190551},
abstract = {Many recent machine learning models rely on fine-grained dynamic control flow for training and inference. In particular, models based on recurrent neural networks and on reinforcement learning depend on recurrence relations, data-dependent conditional execution, and other features that call for dynamic control flow. These applications benefit from the ability to make rapid control-flow decisions across a set of computing devices in a distributed system. For performance, scalability, and expressiveness, a machine learning system must support dynamic control flow in distributed and heterogeneous environments.This paper presents a programming model for distributed machine learning that supports dynamic control flow. We describe the design of the programming model, and its implementation in TensorFlow, a distributed machine learning system. Our approach extends the use of dataflow graphs to represent machine learning models, offering several distinctive features. First, the branches of conditionals and bodies of loops can be partitioned across many machines to run on a set of heterogeneous devices, including CPUs, GPUs, and custom ASICs. Second, programs written in our model support automatic differentiation and distributed gradient computations, which are necessary for training machine learning models that use control flow. Third, our choice of non-strict semantics enables multiple loop iterations to execute in parallel across machines, and to overlap compute and I/O operations.We have done our work in the context of TensorFlow, and it has been used extensively in research and production. We evaluate it using several real-world applications, and demonstrate its performance and scalability.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {18},
numpages = {15},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190530,
author = {Jeong, Eunji and Jeong, Joo Seong and Kim, Soojeong and Yu, Gyeong-In and Chun, Byung-Gon},
title = {Improving the expressiveness of deep learning frameworks with recursion},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190530},
doi = {10.1145/3190508.3190530},
abstract = {Recursive neural networks have widely been used by researchers to handle applications with recursively or hierarchically structured data. However, embedded control flow deep learning frameworks such as TensorFlow, Theano, Caffe2, and MXNet fail to efficiently represent and execute such neural networks, due to lack of support for recursion. In this paper, we add recursion to the programming model of existing frameworks by complementing their design with recursive execution of dataflow graphs as well as additional APIs for recursive definitions. Unlike iterative implementations, which can only understand the topological index of each node in recursive data structures, our recursive implementation is able to exploit the recursive relationships between nodes for efficient execution based on parallel computation. We present an implementation on TensorFlow and evaluation results with various recursive neural network models, showing that our recursive implementation not only conveys the recursive nature of recursive neural networks better than other implementations, but also uses given resources more effectively to reduce training and inference time.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {19},
numpages = {13},
keywords = {automatic differentiation, data flow graph, deep learning framework, programmability, recursive neural network},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190532,
author = {Bindschaedler, Laurent and Malicevic, Jasmina and Schiper, Nicolas and Goel, Ashvin and Zwaenepoel, Willy},
title = {Rock you like a hurricane: taming skew in large scale analytics},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190532},
doi = {10.1145/3190508.3190532},
abstract = {Current cluster computing frameworks suffer from load imbalance and limited parallelism due to skewed data distributions, processing times, and machine speeds. We observe that the underlying cause for these issues in current systems is that they partition work statically. Hurricane is a high-performance large-scale data analytics system that successfully tames skew in novel ways. Hurricane performs adaptive work partitioning based on load observed by nodes at runtime. Overloaded nodes can spawn clones of their tasks at any point during their execution, with each clone processing a subset of the original data. This allows the system to adapt to load imbalance and dynamically adjust task parallelism to gracefully handle skew. We support this design by spreading data across all nodes and allowing nodes to retrieve data in a decentralized way. The result is that Hurricane automatically balances load across tasks, ensuring fast completion times. We evaluate Hurricane's performance on typical analytics workloads and show that it significantly outperforms state-of-the-art systems for both uniform and skewed datasets, because it ensures good CPU and storage utilization in all cases.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {20},
numpages = {15},
keywords = {adaptive work partitioning, analytics, bags, batch sampling, big data, chunks, cluster computing, decentralized storage, distributed scheduling, fine-grained partitioning, high performance, hurricane, late binding, load balancing, merging, repartitioning, skew, storage disaggregation, task cloning},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190550,
author = {Gavrielatos, Vasilis and Katsarakis, Antonios and Joshi, Arpit and Oswald, Nicolai and Grot, Boris and Nagarajan, Vijay},
title = {Scale-out ccNUMA: exploiting skew with strongly consistent caching},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190550},
doi = {10.1145/3190508.3190550},
abstract = {Today's cloud based online services are underpinned by distributed key-value stores (KVS). Such KVS typically use a scale-out architecture, whereby the dataset is partitioned across a pool of servers, each holding a chunk of the dataset in memory and being responsible for serving queries against the chunk. One important performance bottleneck that a KVS design must address is the load imbalance caused by skewed popularity distributions. Despite recent work on skew mitigation, existing approaches offer only limited benefit for high-throughput in-memory KVS deployments.In this paper, we embrace popularity skew as a performance opportunity. Our insight is that aggressively caching popular items at all nodes of the KVS enables both load balance and high throughput - a combination that has eluded previous approaches. We introduce symmetric caching, wherein every server node is provisioned with a small cache that maintains the most popular objects in the dataset. To ensure consistency across the caches, we use high-throughput fully-distributed consistency protocols. A key result of this work is that strong consistency guarantees (per-key linearizability) need not compromise on performance. In a 9-node RDMA-based rack and with modest write ratios, our prototype design, dubbed ccKVS, achieves 2.2x the throughput of the state-of-the-art KVS while guaranteeing strong consistency.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {21},
numpages = {15},
keywords = {RDMA, consistency, key-value stores, replication},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190553,
author = {Kroes, Taddeus and Koning, Koen and van der Kouwe, Erik and Bos, Herbert and Giuffrida, Cristiano},
title = {Delta pointers: buffer overflow checks without the checks},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190553},
doi = {10.1145/3190508.3190553},
abstract = {Despite decades of research, buffer overflows still rank among the most dangerous vulnerabilities in unsafe languages such as C and C++. Compared to other memory corruption vulnerabilities, buffer overflows are both common and typically easy to exploit. Yet, they have proven so challenging to detect in real-world programs that existing solutions either yield very poor performance, or introduce incompatibilities with the C/C++ language standard.We present Delta Pointers, a new solution for buffer overflow detection based on efficient pointer tagging. By carefully altering the pointer representation, without violating language specifications, Delta Pointers use existing hardware features to detect both contiguous and non-contiguous overflows on dereferences, without a single check incurring extra branch or memory access operations. By focusing on buffer overflows rather than other vulnerabilities (e.g., underflows), Delta Pointers offer a unique checkless design to provide high performance while still maintaining compatibility. We show that Delta Pointers are effective in detecting arbitrary buffer overflows and, at 35\% overhead on SPEC, offer much better performance than competing solutions.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {22},
numpages = {14},
keywords = {LLVM, bounds checking, memory safety, pointer tagging},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190529,
author = {Fonseca, Pedro and Wang, Xi and Krishnamurthy, Arvind},
title = {MultiNyx: a multi-level abstraction framework for systematic analysis of hypervisors},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190529},
doi = {10.1145/3190508.3190529},
abstract = {MultiNyx is a new framework designed to systematically analyze modern virtual machine monitors (VMMs), which rely on complex processor extensions to enhance their efficiency. To achieve better scalability, MultiNyx introduces selective, multi-level symbolic execution: it analyzes most instructions at a high semantic level, and leverages an executable specification (e.g., the Bochs CPU emulator) to analyze complex instructions at a low semantic level. MultiNyx seamlessly transitions between these different semantic levels of analysis by converting their state.Our experiments demonstrate that MultiNyx is practical and effective at analyzing VMMs. By applying MultiNyx to KVM, we automatically generated 206,628 test cases. We found that many of these test cases revealed inconsistent results that could have security implications. In particular, 98 test cases revealed different results across KVM configurations running on the Intel architecture, and 641 produced different results across architectures (Intel and AMD). We reported some of these inconsistencies to the KVM developers, one of which already has been patched.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {23},
numpages = {12},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190547,
author = {Aublin, Pierre-Louis and Kelbert, Florian and O'Keeffe, Dan and Muthukumaran, Divya and Priebe, Christian and Lind, Joshua and Krahn, Robert and Fetzer, Christof and Eyers, David and Pietzuch, Peter},
title = {LibSEAL: revealing service integrity violations using trusted execution},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190547},
doi = {10.1145/3190508.3190547},
abstract = {Users of online services such as messaging, code hosting and collaborative document editing expect the services to uphold the integrity of their data. Despite providers' best efforts, data corruption still occurs, but at present service integrity violations are excluded from SLAs. For providers to include such violations as part of SLAs, the competing requirements of clients and providers must be satisfied. Clients need the ability to independently identify and prove service integrity violations to claim compensation. At the same time, providers must be able to refute spurious claims.We describe LibSEAL, a SEcure Audit Library for Internet services that creates a non-repudiable audit log of service operations and checks invariants to discover violations of service integrity. LibSEAL is a drop-in replacement for TLS libraries used by services, and thus observes and logs all service requests and responses. It runs inside a trusted execution environment, such as Intel SGX, to protect the integrity of the audit log. Logs are stored using an embedded relational database, permitting service invariant violations to be discovered using simple SQL queries. We evaluate LibSEAL with three popular online services (Git, ownCloud and Dropbox) and demonstrate that it is effective in discovering integrity violations, while reducing throughput by at most 14\%.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {24},
numpages = {15},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190518,
author = {Krahn, Robert and Trach, Bohdan and Vahldiek-Oberwagner, Anjo and Knauth, Thomas and Bhatotia, Pramod and Fetzer, Christof},
title = {Pesos: policy enhanced secure object store},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190518},
doi = {10.1145/3190508.3190518},
abstract = {Third-party storage services pose the risk of integrity and confidentiality violations as the current storage policy enforcement mechanisms are spread across many layers in the system stack. To mitigate these security vulnerabilities, we present the design and implementation of Pesos, a Policy Enhanced Secure Object Store (Pesos) for untrusted third-party storage providers. Pesos allows clients to specify per-object security policies, concisely and separately from the storage stack, and enforces these policies by securely mediating the I/O in the persistence layer through a single unified enforcement layer. More broadly, Pesos exposes a rich set of storage policies ensuring the integrity, confidentiality, and access accounting for data storage through a declarative policy language.Pesos enforces these policies on untrusted commodity platforms by leveraging a combination of two trusted computing technologies: Intel SGX for trusted execution environment (TEE) and Kinetic Open Storage for trusted storage. We have implemented Pesos as a fully-functional storage system supporting many useful end-to-end storage features, and a range of effective performance optimizations. We evaluated Pesos using a range of micro-benchmarks, and real-world use cases. Our evaluation shows that Pesos incurs reasonable performance overheads for the enforcement of policies while keeping the trusted computing base (TCB) small.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {25},
numpages = {17},
keywords = {intel SGX, kinetic disks, policy language, storage security},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190539,
author = {Lyons, Anna and McLeod, Kent and Almatary, Hesham and Heiser, Gernot},
title = {Scheduling-context capabilities: a principled, light-weight operating-system mechanism for managing time},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190539},
doi = {10.1145/3190508.3190539},
abstract = {Mixed-criticality systems (MCS) combine real-time components of different levels of criticality - i.e. severity of failure - on the same processor, in order to obtain good resource utilisation. They must be able to guarantee deadlines of highly-critical threads without any dependence on less-critical threads. This requires strong temporal isolation, similar to the spatial isolation that is traditionally provided by operating systems, without unnecessary loss of processor utilisation. We present a model that uses scheduling contexts as first-class objects to represent time, and integrates seamlessly with the capability-based protection model of the seL4 microkernel. We show that the model comes with minimal overhead, and supports implementation of arbitrary scheduling policies as well as criticality switches at user level.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {26},
numpages = {16},
keywords = {access control, capabilities, microkernels, mixed-criticality systems, seL4},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190527,
author = {Zhao, Ming and Cabrera, Jorge},
title = {RTVirt: enabling time-sensitive computing on virtualized systems through cross-layer CPU scheduling},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190527},
doi = {10.1145/3190508.3190527},
abstract = {Virtualization enables flexible application delivery and efficient resource consolidation, and is pervasively used to build various virtualized systems including public and private cloud computing systems. Many applications can benefit from computing on virtualized systems, including those that are time sensitive, but it is still challenging for existing virtualized systems to deliver application-desired timeliness. In particular, the lack of awareness between VM host- and guest-level schedulers presents a serious hurdle to achieving strong timeliness guarantees on virtualized systems. This paper presents RTVirt, a new solution to time-sensitive computing on virtualized systems through cross-layer scheduling. It allows the two levels of schedulers on a virtualized system to communicate key scheduling information and coordinate on the scheduling decisions. It enables optimal multiprocessor schedulers to support virtualized time-sensitive applications with strong timeliness guarantees and efficient resource utilization. RTVirt is prototyped on a widely used virtualization framework (Xen) and evaluated with diverse workloads. The results show that it can meet application deadlines (99\%) or tail latency requirements (99.9th percentile) nearly perfectly; it can handle large numbers of applications and dynamic changes in their timeliness requirements; and it substantially outperforms the existing solutions in both timeliness and resource utilization.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {27},
numpages = {13},
keywords = {cloud computing, time-sensitive computing, virtualization},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190557,
author = {Vanga, Manohar and Gujarati, Arpan and Brandenburg, Bj\"{o}rn B.},
title = {Tableau: a high-throughput and predictable VM scheduler for high-density workloads},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190557},
doi = {10.1145/3190508.3190557},
abstract = {In the increasingly competitive public-cloud marketplace, improving the efficiency of data centers is a major concern. One way to improve efficiency is to consolidate as many VMs onto as few physical cores as possible, provided that performance expectations are not violated. However, as a prerequisite for increased VM densities, the hypervisor's VM scheduler must allocate processor time efficiently and in a timely fashion. As we show in this paper, contemporary VM schedulers leave substantial room for improvements in both regards when facing challenging high-VM-density workloads that frequently trigger the VM scheduler. As root causes, we identify (i) high runtime overheads and (ii) unpredictable scheduling heuristics. To better support high VM densities, we propose Tableau, a VM scheduler that guarantees a minimum processor share and a maximum bound on scheduling delay for every VM in the system. Tableau combines a low-overhead, core-local, table-driven dispatcher with a fast on-demand table-generation procedure (triggered on VM creation/teardown) that employs scheduling techniques typically used in hard real-time systems. In an evaluation of Tableau and three current Xen schedulers on a 16-core Intel Xeon machine, Tableau is shown to improve tail latency (e.g., a 17X reduction in maximum ping latency compared to Credit) and throughput (e.g., 1.6X peak web server throughput compared to RTDS when serving 1 KiB files with a 100 ms SLA).},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {28},
numpages = {16},
keywords = {hypervisor scheduling, real-time scheduling, virtualization},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190521,
author = {Ahn, Jeongseob and Park, Chang Hyun and Heo, Taekyung and Huh, Jaehyuk},
title = {Accelerating critical OS services in virtualized systems with flexible micro-sliced cores},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190521},
doi = {10.1145/3190508.3190521},
abstract = {Consolidating multiple virtual machines into a single server has been widely adopted in cloud computing to improve system utilization. However, the sharing of physical CPUs among virtual machines in consolidated systems poses a new challenge in providing an illusion of continuous CPU execution to the guest operating systems (OS). Due to the time-sharing of physical CPUs, the execution of a guest OS is periodically interrupted, while the guest OS may not be aware of the discontinuity of virtual time against the real time. The virtual time discontinuity problem causes the delayed processing of critical OS operations, such as interrupt handling and lock processing. Although there have been several prior studies to mitigate the problem, they address only a subset of symptoms, require the modification of guest OSes, or change the processor architecture. This paper proposes a novel way to comprehensively reduce the inefficiency of guest OS execution in consolidated systems. It migrates the short-lived critical OS tasks to dedicated micro-sliced cores, minimizing the delays caused by time sharing. The hypervisor identifies the critical OS tasks without any OS intervention, and schedules the critical code sections onto the dynamically partitioned cores at runtime. The dedicated micro-sliced cores employ a short sub-millisecond quantum to minimize the response latencies for consolidated virtual machines. By readily servicing the critical tasks, the proposed scheme can minimize the adverse artifact of virtual machine consolidation without any modification of guest OSes.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {29},
numpages = {14},
keywords = {scheduling, virtual time discontinuity, virtualization},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190538,
author = {Androulaki, Elli and Barger, Artem and Bortnikov, Vita and Cachin, Christian and Christidis, Konstantinos and De Caro, Angelo and Enyeart, David and Ferris, Christopher and Laventman, Gennady and Manevich, Yacov and Muralidharan, Srinivasan and Murthy, Chet and Nguyen, Binh and Sethi, Manish and Singh, Gari and Smith, Keith and Sorniotti, Alessandro and Stathakopoulou, Chrysoula and Vukoli\'{c}, Marko and Cocco, Sharon Weed and Yellick, Jason},
title = {Hyperledger fabric: a distributed operating system for permissioned blockchains},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190538},
doi = {10.1145/3190508.3190538},
abstract = {Fabric is a modular and extensible open-source system for deploying and operating permissioned blockchains and one of the Hyperledger projects hosted by the Linux Foundation (www.hyperledger.org).Fabric is the first truly extensible blockchain system for running distributed applications. It supports modular consensus protocols, which allows the system to be tailored to particular use cases and trust models. Fabric is also the first blockchain system that runs distributed applications written in standard, general-purpose programming languages, without systemic dependency on a native cryptocurrency. This stands in sharp contrast to existing block-chain platforms that require "smart-contracts" to be written in domain-specific languages or rely on a cryptocurrency. Fabric realizes the permissioned model using a portable notion of membership, which may be integrated with industry-standard identity management. To support such flexibility, Fabric introduces an entirely novel blockchain design and revamps the way blockchains cope with non-determinism, resource exhaustion, and performance attacks.This paper describes Fabric, its architecture, the rationale behind various design decisions, its most prominent implementation aspects, as well as its distributed application programming model. We further evaluate Fabric by implementing and benchmarking a Bitcoin-inspired digital currency. We show that Fabric achieves end-to-end throughput of more than 3500 transactions per second in certain popular deployment configurations, with sub-second latency, scaling well to over 100 peers.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {30},
numpages = {15},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190541,
author = {Gao, Pin and Yu, Lingfan and Wu, Yongwei and Li, Jinyang},
title = {Low latency RNN inference with cellular batching},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190541},
doi = {10.1145/3190508.3190541},
abstract = {Performing inference on pre-trained neural network models must meet the requirement of low-latency, which is often at odds with achieving high throughput. Existing deep learning systems use batching to improve throughput, which do not perform well when serving Recurrent Neural Networks with dynamic dataflow graphs. We propose the technique of cellular batching, which improves both the latency and throughput of RNN inference. Unlike existing systems that batch a fixed set of dataflow graphs, cellular batching makes batching decisions at the granularity of an RNN "cell" (a subgraph with shared weights) and dynamically assembles a batched cell for execution as requests join and leave the system. We implemented our approach in a system called BatchMaker. Experiments show that BatchMaker achieves much lower latency and also higher throughput than existing systems.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {31},
numpages = {15},
keywords = {batching, dataflow graph, inference, recurrent neural network},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190545,
author = {Chen, Hongzhi and Liu, Miao and Zhao, Yunjian and Yan, Xiao and Yan, Da and Cheng, James},
title = {G-Miner: an efficient task-oriented graph mining system},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190545},
doi = {10.1145/3190508.3190545},
abstract = {Graph mining is one of the most important areas in data mining. However, scalable solutions for graph mining are still lacking as existing studies focus on sequential algorithms. While many distributed graph processing systems have been proposed in recent years, most of them were designed to parallelize computations such as PageRank and Breadth-First Search that keep states on individual vertices and propagate updates along edges. Graph mining, on the other hand, may generate many subgraphs whose number can far exceed the number of vertices. This inevitably leads to much higher computational and space complexity rendering existing graph systems inefficient. We propose G-Miner, a distributed system with a new architecture designed for general graph mining. G-Miner adopts a unified programming framework for implementing a wide range of graph mining algorithms. We model subgraph processing as independent tasks, and design a novel task pipeline to streamline task processing for better CPU, network and I/O utilization. Our extensive experiments validate the efficiency of G-Miner for a range of graph mining tasks.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {32},
numpages = {12},
keywords = {distributed system, large-scale graph mining},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190546,
author = {Kakivaya, Gopal and Xun, Lu and Hasha, Richard and Ahsan, Shegufta Bakht and Pfleiger, Todd and Sinha, Rishi and Gupta, Anurag and Tarta, Mihail and Fussell, Mark and Modi, Vipul and Mohsin, Mansoor and Kong, Ray and Ahuja, Anmol and Platon, Oana and Wun, Alex and Snider, Matthew and Daniel, Chacko and Mastrian, Dan and Li, Yang and Rao, Aprameya and Kidambi, Vaishnav and Wang, Randy and Ram, Abhishek and Shivaprakash, Sumukh and Nair, Rajeet and Warwick, Alan and Narasimman, Bharat S. and Lin, Meng and Chen, Jeffrey and Mhatre, Abhay Balkrishna and Subbarayalu, Preetha and Coskun, Mert and Gupta, Indranil},
title = {Service fabric: a distributed platform for building microservices in the cloud},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190546},
doi = {10.1145/3190508.3190546},
abstract = {We describe Service Fabric (SF), Microsoft's distributed platform for building, running, and maintaining microservice applications in the cloud. SF has been running in production for 10+ years, powering many critical services at Microsoft. This paper outlines key design philosophies in SF. We then adopt a bottom-up approach to describe low-level components in its architecture, focusing on modular use and support for strong semantics like fault-tolerance and consistency within each component of SF. We discuss lessons learned, and present experimental results from production data.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {33},
numpages = {15},
keywords = {distributed systems, failure detection, microservices, production systems, scheduling},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190510,
author = {Kashyap, Sanidhya and Min, Changwoo and Kim, Kangnyeon and Kim, Taesoo},
title = {A scalable ordering primitive for multicore machines},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190510},
doi = {10.1145/3190508.3190510},
abstract = {Timestamping is an essential building block for designing concurrency control mechanisms and concurrent data structures. Various algorithms either employ physical timestamping, assuming that they have access to synchronized clocks, or maintain a logical clock with the help of atomic instructions. Unfortunately, these approaches have two problems. First, hardware developers do not guarantee that the available hardware clocks are exactly synchronized, which they find difficult to achieve in practice. Second, the atomic instructions are a deterrent to scalability resulting from cache-line contention. This paper addresses these problems by proposing and designing a scalable ordering primitive, called Ordo, that relies on invariant hardware clocks. Ordo not only enables the correct use of these clocks, by providing a notion of a global hardware clock, but also frees various logical timestamp-based algorithms from the burden of the software logical clock, while trying to simplify their design. We use the Ordo primitive to redesign 1) a concurrent data structure library that we apply on the Linux kernel; 2) a synchronization mechanism for concurrent programming; 3) two database concurrency control mechanisms; and 4) a clock-based software transactional memory algorithm. Our evaluation shows that there is a possibility that the clocks are not synchronized on two architectures (Intel and ARM) and that Ordo generally improves the efficiency of several algorithms by 1.2--39.7X on various architectures.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {34},
numpages = {15},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190512,
author = {Suo, Kun and Rao, Jia and Jiang, Hong and Srisa-an, Witawas},
title = {Characterizing and optimizing hotspot parallel garbage collection on multicore systems},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190512},
doi = {10.1145/3190508.3190512},
abstract = {The proliferation of applications, frameworks, and services built on Java have led to an ecosystem critically dependent on the underlying runtime system, the Java virtual machine (JVM). However, many applications running on the JVM, e.g., big data analytics, suffer from long garbage collection (GC) time. The long pause time due to GC not only degrades application throughput and causes long latency, but also hurts overall system efficiency and scalability.In this paper, we present an in-depth performance analysis of GC in the widely-adopted HotSpot JVM. Our analysis uncovers a previously unknown performance issue - the design of dynamic GC task assignment, the unfairness of mutex lock acquisition in HotSpot, and the imperfect operating system (OS) load balancing together cause loss of concurrency in Parallel Scavenge, a state-of-the-art and the default garbage collector in HotSpot. To this end, we propose a number of solutions to these issues, including enforcing GC thread affinity to aid multicore load balancing and designing a more efficient work stealing algorithm. Performance evaluation demonstrates that these proposed approaches lead to the improvement of the overall completion time, GC time and application tail latency by as much as 49.6\%, 87.1\%, 43\%, respectively.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {35},
numpages = {15},
keywords = {garbage collection, java virtual machine, multicore, performance},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190523,
author = {Min, Changwoo and Kang, Woonhak and Kumar, Mohan and Kashyap, Sanidhya and Maass, Steffen and Jo, Heeseung and Kim, Taesoo},
title = {Solros: a data-centric operating system architecture for heterogeneous computing},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190523},
doi = {10.1145/3190508.3190523},
abstract = {We propose Solros---a new operating system architecture for heterogeneous systems that comprises fast host processors, slow but massively parallel co-processors, and fast I/O devices. A general consensus to fully drive such a hardware system is to have a tight integration among processors and I/O devices. Thus, in the Solros architecture, a co-processor OS (data-plane OS) delegates its services, specifically I/O stacks, to the host OS (control-plane OS). Our observation for such a design is that global coordination with system-wide knowledge (e.g., PCIe topology, a load of each co-processor) and the best use of heterogeneous processors is critical to achieving high performance. Hence, we fully harness these specialized processors by delegating complex I/O stacks on fast host processors, which leads to an efficient global coordination at the level of the control-plane OS.We developed Solros with Xeon Phi co-processors and implemented three core OS services: transport, file system, and network services. Our experimental results show significant performance improvement compared with the stock Xeon Phi running the Linux kernel. For example, Solros improves the throughput of file system and network operations by 19x and 7x, respectively. Moreover, it improves the performance of two realistic applications: 19x for text indexing and 2x for image search.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {36},
numpages = {15},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190533,
author = {Guo, Liwei and Xu, Tiantu and Xu, Mengwei and Liu, Xuanzhe and Lin, Felix Xiaozhu},
title = {Power sandbox: power awareness redefined},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190533},
doi = {10.1145/3190508.3190533},
abstract = {Many apps benefit from knowing their power consumption and adapting their behaviors on the fly. To offer apps power knowledge at run time, an OS often meters system power and divides it among apps. Since the impacts of concurrent apps on system power are entangled, this approach not only makes it difficult to reason about power but also results in power side channels, a serious vulnerability.To this end, we introduce a new OS principal called power sandbox, which enables one app to observe the fine-grained power consumption of itself running in its vertical slice of the hardware/software stack. The observed power is insulated from the impacts of other apps. Our contribution is a set of lightweight kernel extensions that simultaneously i) enforce the power sandbox boundaries and ii) confine entailed performance loss to the sandboxed apps. Our experiences on two embedded platforms show that power sandboxes simplify reasoning about power, maintain fairness among apps, and minimize power side channels, thus facilitating construction of power-aware apps.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {37},
numpages = {15},
keywords = {embedded systems, energy efficiency, operating systems, power awareness},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190543,
author = {Morris, Nathaniel and Stewart, Christopher and Chen, Lydia and Birke, Robert and Kelley, Jaimie},
title = {Model-driven computational sprinting},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190543},
doi = {10.1145/3190508.3190543},
abstract = {Computational sprinting speeds up query execution by increasing power usage for short bursts. Sprinting policy decides when and how long to sprint. Poor policies inflate response time significantly. We propose a model-driven approach that chooses between sprinting policies based on their expected response time. However, sprinting alters query executions at runtime, creating a complex dependency between queuing and processing time. Our performance modeling approach employs offline profiling, machine learning, and first-principles simulation. Collectively, these modeling techniques capture the effects of sprinting on response time. We validated our modeling approach with 3 sprinting mechanisms across 9 workloads. Our performance modeling approach predicted response time with median error below 4\% in most tests and median error of 11\% in the worst case. We demonstrated model-driven sprinting for cloud providers seeking to colocate multiple workloads on AWS Burstable Instances while meeting service level objectives. Model-driven sprinting uncovered policies that achieved response time goals, allowing more workloads to colocate on a node. Compared to AWS Burstable policies, our approach increased revenue per node by 1.6X.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {38},
numpages = {13},
keywords = {CPU throttling, accuracy, amazon web services, burstable instance, computational sprinting, prediction, queuing models, random decision forest, resource management, simulation, system models},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190536,
author = {Taranov, Konstantin and Alonso, Gustavo and Hoefler, Torsten},
title = {Fast and strongly-consistent per-item resilience in key-value stores},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190536},
doi = {10.1145/3190508.3190536},
abstract = {In-memory key-value stores (KVSs) provide different forms of resilience through basic r-way replication and complex erasure codes such as Reed-Solomon. Each storage scheme exhibits different tradeoffs in terms of reliability and resources used (memory, network load, latency, storage required, etc.). Unfortunately, most KVSs support only a single such storage scheme, forcing designers to employ different KVSs for different applications. To address this problem, we have designed a strongly consistent in-memory KVS, Ring, that empowers its users to set the level of resilience on a KV pair basis while still maintaining overall consistency and without compromising efficiency. At the heart of Ring lies a novel encoding scheme, Stretched Reed-Solomon coding, that combines hash key distributions of heterogeneous replication and erasure coding schemes. Ring utilizes RDMA to ensure low latencies and offload communication tasks. Its latency, bandwidth, and throughput are comparable to state-of-the-art systems that do not support changing resilience and, thus, have much higher memory overheads. We show use cases that demonstrate significant memory savings and discuss trade-offs between reliability, performance, and cost. Our work demonstrates how future applications that consciously manage resilience of KV pairs can reduce the overall operational cost and significantly improve the performance of KVS deployments.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {39},
numpages = {14},
keywords = {key-value store, reed-solomon, replication, resilience management},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190542,
author = {Ghosh, Mainak and Raina, Ashwini and Xu, Le and Qian, Xiaoyao and Gupta, Indranil and Gupta, Himanshu},
title = {Popular is cheaper: curtailing memory costs in interactive analytics engines},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190542},
doi = {10.1145/3190508.3190542},
abstract = {This paper targets the growing area of interactive data analytics engines. We present a system called Getafix that intelligently decides replication levels and replica placement for data segments, in a way that is responsive to changing popularity of data access by incoming queries. We present an optimal solution to the static version of the problem, achieving minimality in both makespan and replication factor. Based on this intuition we build the Getafix system to handle queries and segments arriving in real time. We integrated Getafix into Druid, a modern open-source interactive data analytics engine. We present experimental results using workloads from Yahoo!'s production Druid cluster. Compared to existing work, Getafix achieves comparable query latency (both average and tail), while using 1.45--2.15 x less memory in a private cloud. In a public cloud, for a 100 TB hot dataset size, Getafix can cut dollar costs by as much as 10 million annually with negligible performance impact.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {40},
numpages = {14},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190522,
author = {Prasad, Aravinda and Gopinath, K},
title = {A frugal approach to reduce RCU grace period overhead},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190522},
doi = {10.1145/3190508.3190522},
abstract = {Grace period computation is a core part of the Read-Copy-Update (RCU) synchronization technique that determines the safe time to reclaim the deferred objects' memory. We first show that the eager grace period computation employed in the Linux kernel is appropriate only for enterprise workloads such as web and database servers where a large amount of reclaimable memory awaits the completion of a grace period. However, such memory is negligible in High-Performance Computing (HPC) and mostly idling environments due to limited OS kernel activity. Hence an eager approach is not only futile but also detrimental as the CPU cycles consumed to compute a grace period leads to jitter in HPC and frequent CPU wake-ups in idle environments.We design frugal grace periods, an economical grace period computation for non-enterprise environments that consume fewer CPU cycles. In addition, we reduce the number of grace periods either by using heuristics or by letting the memory allocator to explicitly request for a grace period only when it is running out of free objects. Our implementation in the Linux kernel reduces the number of grace periods by 68\% to 99\%, reduces the CPU time consumed by grace periods by 39\% to 99\%, improves the throughput by up to 28\% for NAS parallel benchmarks and increases the CPU time spent in low power states by 2.4x when the system is idle.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {41},
numpages = {15},
keywords = {dynamic memory allocator, grace periods, jitter, power management, read-copy-update (RCU)},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190524,
author = {Eisenman, Assaf and Gardner, Darryl and AbdelRahman, Islam and Axboe, Jens and Dong, Siying and Hazelwood, Kim and Petersen, Chris and Cidon, Asaf and Katti, Sachin},
title = {Reducing DRAM footprint with NVM in Facebook},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190524},
doi = {10.1145/3190508.3190524},
abstract = {Popular SSD-based key-value stores consume a large amount of DRAM in order to provide high-performance database operations. However, DRAM can be expensive for data center providers, especially given recent global supply shortages that have resulted in increasing DRAM costs. In this work, we design a key-value store, MyNVM, which leverages an NVM block device to reduce DRAM usage, and to reduce the total cost of ownership, while providing comparable latency and queries-per-second (QPS) as MyRocks on a server with a much larger amount of DRAM. Replacing DRAM with NVM introduces several challenges. In particular, NVM has limited read bandwidth, and it wears out quickly under a high write bandwidth.We design novel solutions to these challenges, including using small block sizes with a partitioned index, aligning blocks post-compression to reduce read bandwidth, utilizing dictionary compression, implementing an admission control policy for which objects get cached in NVM to control its durability, as well as replacing interrupts with a hybrid polling mechanism. We implemented MyNVM and measured its performance in Facebook's production environment. Our implementation reduces the size of the DRAM cache from 96 GB to 16 GB, and incurs a negligible impact on latency and queries-per-second compared to MyRocks. Finally, to the best of our knowledge, this is the first study on the usage of NVM devices in a commercial data center environment.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {42},
numpages = {13},
location = {Porto, Portugal},
series = {EuroSys '18}
}

@inproceedings{10.1145/3190508.3190534,
author = {Zhang, Haoyu and Cho, Brian and Seyfe, Ergin and Ching, Avery and Freedman, Michael J.},
title = {Riffle: optimized shuffle service for large-scale data analytics},
year = {2018},
isbn = {9781450355841},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3190508.3190534},
doi = {10.1145/3190508.3190534},
abstract = {The rapidly growing size of data and complexity of analytics present new challenges for large-scale data processing systems. Modern systems keep data partitions in memory for pipelined operators, and persist data across stages with wide dependencies on disks for fault tolerance. While processing can often scale well by splitting jobs into smaller tasks for better parallelism, all-to-all data transfer---called shuffle operations---become the scaling bottleneck when running many small tasks in multi-stage data analytics jobs. Our key observation is that this bottleneck is due to the superlinear increase in disk I/O operations as data volume increases.We present Riffle, an optimized shuffle service for big-data analytics frameworks that significantly improves I/O efficiency and scales to process petabytes of data. To do so, Riffle efficiently merges fragmented intermediate shuffle files into larger block files, and thus converts small, random disk I/O requests into large, sequential ones. Riffle further improves performance and fault tolerance by mixing both merged and unmerged block files to minimize merge operation overhead. Using Riffle, Facebook production jobs on Spark clusters with over 1,000 executors experience up to a 10x reduction in the number of shuffle I/O requests and 40\% improvement in the end-to-end job completion time.},
booktitle = {Proceedings of the Thirteenth EuroSys Conference},
articleno = {43},
numpages = {15},
keywords = {I/O optimization, big-data analytics frameworks, shuffle service, storage},
location = {Porto, Portugal},
series = {EuroSys '18}
}