@inproceedings{10.1145/3064176.3064189,
author = {Su, Maomeng and Zhang, Mingxing and Chen, Kang and Guo, Zhenyu and Wu, Yongwei},
title = {RFP: When RPC is Faster than Server-Bypass with RDMA},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064189},
doi = {10.1145/3064176.3064189},
abstract = {Remote Direct Memory Access (RDMA) has been widely deployed in modern data centers. However, existing usages of RDMA lead to a dilemma between performance and redesign cost. They either directly replace socket-based send/receive primitives with the corresponding RDMA counterpart (server-reply), which only achieves moderate performance improvement; or push performance further by using one-sided RDMA operations to totally bypass the server (server-bypass), at the cost of redesigning the software.In this paper, we introduce two interesting observations about RDMA. First, RDMA has asymmetric performance characteristics, which can be used to improve server-reply's performance. Second, the performance of server-bypass is not as good as expected in many cases, because more rounds of RDMA may be needed if the server is totally bypassed. We therefore introduce a new RDMA paradigm called Remote Fetching Paradigm (RFP). Although RFP requires users to set several parameters to achieve the best performance, it supports the legacy RPC interfaces and hence avoids the need of redesigning application-specific data structures. Moreover, with proper parameters, it can achieve even higher IOPS than that of the previous paradigms.We have designed and implemented an in-memory key-value store based on RFP to evaluate its effectiveness. Experimental results show that RFP improves performance by 1.6\texttimes{}~4\texttimes{} compared with both server-reply and server-bypass paradigms.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {1–15},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064197,
author = {Vilanova, Llu\'{\i}s and Jord\`{a}, Marc and Navarro, Nacho and Etsion, Yoav and Valero, Mateo},
title = {Direct Inter-Process Communication (dIPC): Repurposing the CODOMs Architecture to Accelerate IPC},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064197},
doi = {10.1145/3064176.3064197},
abstract = {In current architectures, page tables are the fundamental mechanism that allows contemporary OSs to isolate user processes, binding each thread to a specific page table. A thread cannot therefore directly call another process's function or access its data; instead, the OS kernel provides data communication primitives and mediates process synchronization through inter-process communication (IPC) channels, which impede system performance.Alternatively, the recently proposed CODOMs architecture provides memory protection across software modules. Threads can cross module protection boundaries inside the same process using simple procedure calls, while preserving memory isolation.We present dIPC (for "direct IPC"), an OS extension that repurposes and extends the CODOMs architecture to allow threads to cross process boundaries. It maps processes into a shared address space, and eliminates the OS kernel from the critical path of inter-process communication. dIPC is 64.12\texttimes{} faster than local remote procedure calls (RPCs), and 8.87\texttimes{} faster than IPC in the L4 microkernel. We show that applying dIPC to a multi-tier OLTP web server improves performance by up to 5.12\texttimes{} (2.13\texttimes{} on average), and reaches over 94\% of the ideal system efficiency.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {16–31},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064201,
author = {Ghorbani, Soudeh and Godfrey, P. Brighten},
title = {COCONUT: Seamless Scale-out of Network Elements},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064201},
doi = {10.1145/3064176.3064201},
abstract = {A key use of software-defined networking is to enable scale-out of network data plane elements. Naively scaling networking elements, however, can cause incorrect behavior. For example, we show that an IDS system which operates correctly as a single network element can erroneously and permanently block hosts when it is replicated.In this paper, we provide a system, COCONUT, for seamless scale-out of network forwarding elements; that is, an SDN application programmer can program to what functionally appears to be a single forwarding element, but which may be replicated behind the scenes. To do this, we identify the key property for seamless scale out, weak causality, and guarantee it through a practical and scalable implementation of vector clocks in the data plane. We prove that COCONUT enables seamless scale out of networking elements, i.e., the user-perceived behavior of any COCONUT element implemented with a distributed set of concurrent replicas is provably indistinguishable from its singleton implementation. Finally, we build a prototype of COCONUT and experimentally demonstrate its correct behavior. We also show that its abstraction enables a more efficient implementation of seamless scale-out compared to a naive baseline.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {32–47},
numpages = {16},
keywords = {Consistency, Correctness, Network Functions, One Big Switch, One-to-many Mapping, Replication, Software Defined Networking, Virtualization, Weak Causal Consistency},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064202,
author = {Liu, Feilong and Yin, Lingyan and Blanas, Spyros},
title = {Design and Evaluation of an RDMA-aware Data Shuffling Operator for Parallel Database Systems},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064202},
doi = {10.1145/3064176.3064202},
abstract = {The commoditization of high-performance networking has sparked research interest in the RDMA capability of this hardware. One-sided RDMA primitives, in particular, have generated substantial excitement due to the ability to directly access remote memory from within an application without involving the TCP/IP stack or the remote CPU. This paper considers how to leverage RDMA to improve the analytical performance of parallel database systems. To shuffle data efficiently using RDMA, one needs to consider a complex design space that includes (1) the number of open connections, (2) the contention for the shared network interface, (3) the RDMA transport function, and (4) how much memory should be reserved to exchange data between nodes during query processing. We contribute six designs that capture salient trade-offs in this design space. We comprehensively evaluate how transport-layer decisions impact the query performance of a database system for different generations of InfiniBand. We find that a shuffling operator that uses the RDMA Send/Receive transport function over the Unreliable Datagram transport service can transmit data up to 4\texttimes{} faster than an RDMA-capable MPI implementation in a 16-node cluster. The response time of TPC-H queries improves by as much as 2\texttimes{}.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {48–63},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064179,
author = {Huang, Jiamin and Mozafari, Barzan and Wenisch, Thomas F.},
title = {Statistical Analysis of Latency Through Semantic Profiling},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064179},
doi = {10.1145/3064176.3064179},
abstract = {Most software profiling tools quantify average performance and rely on a program's control flow graph to organize and report results. However, in interactive server applications, performance predictability is often an equally important measure. Moreover, the end user is often concerned with the performance of a semantically defined interval of execution, such as a request or transaction, which may not directly map to any single function in the call graph, especially in high-performance applications that use asynchrony or event-based programming. It is difficult to distinguish functionality that lies on the critical path of a semantic interval from other activity (e.g., periodic logging or side operations) that may nevertheless appear prominent in a conventional profile. Existing profilers lack the ability to (i) aggregate results for a semantic interval and (ii) attribute its performance variance to individual functions.We propose a profiler called VProfiler that, given the source code of a software system and programmer annotations indicating the start and end of semantic intervals of interest, is able to identify the dominant sources of latency variance in a semantic context. Using a novel abstraction, called a variance tree, VProfiler analyzes the thread interleaving and deconstructs overall latency variance into variances and covariances of the execution time of individual functions. It then aggregates latency variance along a backwards path of dependence relationships among threads from the end of an interval to its start. We evaluate VProfiler's effectiveness on three popular open-source projects (MySQL, Postgres, and Apache Web Server). By identifying a few culprit functions in these complex code bases, VProfiler allows us to eliminate 27\%--82\% of the overall latency variance of these systems with a modest programming effort.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {64–79},
numpages = {16},
keywords = {Performance, Predictability, Semantic Profiling, Tail Latencies, Variance},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064193,
author = {Balmau, Oana and Guerraoui, Rachid and Trigonakis, Vasileios and Zablotchi, Igor},
title = {FloDB: Unlocking Memory in Persistent Key-Value Stores},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064193},
doi = {10.1145/3064176.3064193},
abstract = {Log-structured merge (LSM) data stores enable to store and process large volumes of data while maintaining good performance. They mitigate the I/O bottleneck by absorbing updates in a memory layer and transferring them to the disk layer in sequential batches. Yet, the LSM architecture fundamentally requires elements to be in sorted order. As the amount of data in memory grows, maintaining this sorted order becomes increasingly costly. Contrary to intuition, existing LSM systems could actually lose throughput with larger memory components.In this paper, we introduce FloDB, an LSM memory component architecture which allows throughput to scale on modern multicore machines with ample memory sizes. The main idea underlying FloDB is essentially to bootstrap the traditional LSM architecture by adding a small in-memory buffer layer on top of the memory component. This buffer offers low-latency operations, masking the write latency of the sorted memory component. Integrating this buffer in the classic LSM memory component to obtain FloDB is not trivial and requires revisiting the algorithms of the user-facing LSM operations (search, update, scan). FloDB's two layers can be implemented with state-of-the-art, highly-concurrent data structures. This way, as we show in the paper, FloDB eliminates significant synchronization bottlenecks in classic LSM designs, while offering a rich LSM API.We implement FloDB as an extension of LevelDB, Google's popular LSM key-value store. We compare FloDB's performance to that of state-of-the-art LSMs. In short, FloDB's performance is up to one order of magnitude higher than that of the next best-performing competitor in a wide range of multi-threaded workloads.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {80–94},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064209,
author = {Reda, Waleed and Canini, Marco and Suresh, Lalith and Kosti\'{c}, Dejan and Braithwaite, Sean},
title = {Rein: Taming Tail Latency in Key-Value Stores via Multiget Scheduling},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064209},
doi = {10.1145/3064176.3064209},
abstract = {We tackle the problem of reducing tail latencies in distributed key-value stores, such as the popular Cassandra database. We focus on workloads of multiget requests, which batch together access to several data elements and parallelize read operations across the data store machines. We first analyze a production trace of a real system and quantify the skew due to multiget sizes, key popularity, and other factors. We then proceed to identify opportunities for reduction of tail latencies by recognizing the composition of aggregate requests and by carefully scheduling bottleneck operations that can otherwise create excessive queues. We design and implement a system called Rein, which reduces latency via inter-multiget scheduling using low overhead techniques. We extensively evaluate Rein via experiments in Amazon Web Services (AWS) and simulations. Our scheduling algorithms reduce the median, 95th, and 99th percentile latencies by factors of 1.5, 1.5, and 1.9, respectively.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {95–110},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064210,
author = {Bravo, Manuel and Rodrigues, Lu\'{\i}s and Van Roy, Peter},
title = {Saturn: a Distributed Metadata Service for Causal Consistency},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064210},
doi = {10.1145/3064176.3064210},
abstract = {This paper presents the design, implementation, and evaluation of Saturn, a metadata service for geo-replicated systems. Saturn can be used in combination with several distributed and replicated data services to ensure that remote operations are made visible in an order that respects causality, a requirement central to many consistency criteria.Saturn addresses two key unsolved problems inherent to previous approaches. First, it eliminates the tradeoff between throughput and data freshness, when deciding what metadata to use for tracking causality. Second, it enables genuine partial replication, a key property to ensure scalability when the number of geo-locations increases. Saturn addresses these challenges while keeping metadata size constant, independently of the number of clients, servers, data partitions, and locations. By decoupling metadata management from data dissemination, and by using clever metadata propagation techniques, it ensures that the throughput and visibility latency of updates on a given item are (mostly) shielded from operations on other items or locations.We evaluate Saturn in Amazon EC2 using realistic benchmarks under both full and partial geo-replication. Results show that weakly consistent datastores can lean on Saturn to upgrade their consistency guarantees to causal consistency with a negligible penalty on performance.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {111–126},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064187,
author = {He, Jun and Kannan, Sudarsun and Arpaci-Dusseau, Andrea C. and Arpaci-Dusseau, Remzi H.},
title = {The Unwritten Contract of Solid State Drives},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064187},
doi = {10.1145/3064176.3064187},
abstract = {We perform a detailed vertical analysis of application performance atop a range of modern file systems and SSD FTLs. We formalize the "unwritten contract" that clients of SSDs should follow to obtain high performance, and conduct our analysis to uncover application and file system designs that violate the contract. Our analysis, which utilizes a highly detailed SSD simulation underneath traces taken from real workloads and file systems, provides insight into how to better construct applications, file systems, and FTLs to realize robust and sustainable performance.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {127–144},
numpages = {18},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064188,
author = {Davis, James and Thekumparampil, Arun and Lee, Dongyoon},
title = {Node.fz: Fuzzing the Server-Side Event-Driven Architecture},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064188},
doi = {10.1145/3064176.3064188},
abstract = {The importance of the Event-Driven Architecture (EDA) has never been greater. Web servers and the IoT alike have begun to adopt the EDA, and the popular server-side EDA framework, Node.js, boasts the world's largest package ecosystem. While multi-threaded programming has been well studied in the literature, concurrency bug characteristics and useful development tools remain largely unexplored for server-side EDA-based applications.We present the first (to the best of our knowledge) concurrency bug characteristic study of real world open-source event-driven applications, based in Node.js. Like multithreaded programs, event-driven programs are prone to concurrency bugs like atomicity violations and order violations. Our study shows the forms that atomicity violations and ordering violations take in the EDA context, and points out the limitations of existing concurrency error detection tools developed for client-side EDA applications.Based on our bug study, we propose Node.fz, a novel testing aid for server-side event-driven programs. Node.fz is a schedule fuzzing test tool for event-driven programs, embodied for server-side Node.js programs. Node.fz randomly perturbs the execution of a Node.js program, allowing Node.js developers to explore a variety of possible schedules. Thanks to its low overhead, Node.fz enables a developer to explore a broader "schedule space" with the same test time budget, ensuring that applications will be stable in a wide variety of deployment conditions. We show that Node.fz can expose known bugs much more frequently than vanilla Node.js, and that it can uncover new bugs.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {145–160},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064207,
author = {Yan, Wenrui and Yao, Jie and Cao, Qiang and Xie, Changsheng and Jiang, Hong},
title = {ROS: A Rack-based Optical Storage System with Inline Accessibility for Long-Term Data Preservation},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064207},
doi = {10.1145/3064176.3064207},
abstract = {The combination of the explosive growth in digital data and the need to preserve much of this data in the long term has made it an imperative to find a more cost-effective way than HDD arrays and more easily accessible way than tape libraries to store massive amounts of data. While modern optical discs are capable of guaranteeing more than 50-year data preservation without migration, individual optical disks' lack of the performance and capacity relative to HDDs or tapes has significantly limited their use in datacenters. This paper presents a Rack-scale Optical disc library System, or ROS in short, that provides a PB-level total capacity and inline accessibility on thousands of optical discs built within a 42U Rack. A rotatable roller and robotic arm separating and fetching the discs are designed to improve disc placement density and simplify the mechanical structure. A hierarchical storage system based on SSD, hard disks and optical discs are presented to hide the delay of mechanical operation. On the other hand, an optical library file system is proposed to schedule mechanical operation and organize data on the tiered storage with a POSIX user interface to provide an illusion of inline data accessibility. We evaluate ROS on a few key performance metrics including operation delays of the mechanical structure and software overhead in a prototype PB-level ROS system. The results show that ROS stacked on Samba and FUSE can provide almost 323MB/s read and 236MB/s write throughput, about 53ms file write and 15ms read latency via 10GbE network for external users, exhibiting its inline accessibility. Besides, ROS is able to effectively hide and virtualize internal complex operational behaviors and be easily deployable in datacenters.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {161–174},
numpages = {14},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064208,
author = {Sevilla, Michael A. and Watkins, Noah and Jimenez, Ivo and Alvaro, Peter and Finkelstein, Shel and LeFevre, Jeff and Maltzahn, Carlos},
title = {Malacology: A Programmable Storage System},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064208},
doi = {10.1145/3064176.3064208},
abstract = {Storage systems need to support high-performance for special-purpose data processing applications that run on an evolving storage device technology landscape. This puts tremendous pressure on storage systems to support rapid change both in terms of their interfaces and their performance. But adapting storage systems can be difficult because unprincipled changes might jeopardize years of code-hardening and performance optimization efforts that were necessary for users to entrust their data to the storage system. We introduce the programmable storage approach, which exposes internal services and abstractions of the storage stack as building blocks for higher-level services. We also build a prototype to explore how existing abstractions of common storage system services can be leveraged to adapt to the needs of new data processing systems and the increasing variety of storage devices. We illustrate the advantages and challenges of this approach by composing existing internal abstractions into two new higher-level services: a file system metadata load balancer and a high-performance distributed shared-log. The evaluation demonstrates that our services inherit desirable qualities of the back-end storage system, including the ability to balance load, efficiently propagate service metadata, recover from failure, and navigate trade-offs between latency and throughput using leases.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {175–190},
numpages = {16},
keywords = {Ceph, Distributed Storage, Programmability},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064184,
author = {Zheng, Wenting and Li, Frank and Popa, Raluca Ada and Stoica, Ion and Agarwal, Rachit},
title = {MiniCrypt: Reconciling Encryption and Compression for Big Data Stores},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064184},
doi = {10.1145/3064176.3064184},
abstract = {We propose MiniCrypt, the first key-value store that reconciles encryption and compression without compromising performance. At the core of MiniCrypt is an observation on data compressibility trends in key-value stores, which enables grouping key-value pairs into small key packs, together with a set of distributed systems techniques for retrieving, updating, merging and splitting encrypted packs. Our evaluation shows that MiniCrypt compresses data by as much as 4 times with respect to the vanilla key-value store, and can increase the server's throughput by up to two orders of magnitude by fitting more data in main memory.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {191–204},
numpages = {14},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064192,
author = {Kuvaiskii, Dmitrii and Oleksenko, Oleksii and Arnautov, Sergei and Trach, Bohdan and Bhatotia, Pramod and Felber, Pascal and Fetzer, Christof},
title = {SGXBOUNDS: Memory Safety for Shielded Execution},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064192},
doi = {10.1145/3064176.3064192},
abstract = {Shielded execution based on Intel SGX provides strong security guarantees for legacy applications running on untrusted platforms. However, memory safety attacks such as Heartbleed can render the confidentiality and integrity properties of shielded execution completely ineffective. To prevent these attacks, the state-of-the-art memory-safety approaches can be used in the context of shielded execution.In this work, we first showcase that two prominent software- and hardware-based defenses, AddressSanitizer and Intel MPX respectively, are impractical for shielded execution due to high performance and memory overheads. This motivated our design of SGXBounds---an efficient memory-safety approach for shielded execution exploiting the architectural features of Intel SGX. Our design is based on a simple combination of tagged pointers and compact memory layout.We implemented SGXBounds based on the LLVM compiler framework targeting unmodified multithreaded applications. Our evaluation using Phoenix, PARSEC, and RIPE benchmark suites shows that SGXBounds has performance and memory overheads of 17\% and 0.1\% respectively, while providing security guarantees similar to AddressSanitizer and Intel MPX. We have obtained similar results with SPEC CPU2006 and four real-world case studies: SQLite, Memcached, Apache, and Nginx.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {205–221},
numpages = {17},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064213,
author = {Behl, Johannes and Distler, Tobias and Kapitza, R\"{u}diger},
title = {Hybrids on Steroids: SGX-Based High Performance BFT},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064213},
doi = {10.1145/3064176.3064213},
abstract = {With the advent of trusted execution environments provided by recent general purpose processors, a class of replication protocols has become more attractive than ever: Protocols based on a hybrid fault model are able to tolerate arbitrary faults yet reduce the costs significantly compared to their traditional Byzantine relatives by employing a small subsystem trusted to only fail by crashing. Unfortunately, existing proposals have their own price: We are not aware of any hybrid protocol that is backed by a comprehensive formal specification, complicating the reasoning about correctness and implications. Moreover, current protocols of that class have to be performed largely sequentially. Hence, they are not well-prepared for just the modern multi-core processors that bring their very own fault model to a broad audience. In this paper, we present Hybster, a new hybrid state-machine replication protocol that is highly parallelizable and specified formally. With over 1 million operations per second using only four cores, the evaluation of our Intel SGX-based prototype implementation shows that Hybster makes hybrid state-machine replication a viable option even for today's very demanding critical services.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {222–237},
numpages = {16},
keywords = {Multi-Core, Scalability, State-Machine Replication, Trusted Execution},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064219,
author = {Orenbach, Meni and Lifshits, Pavel and Minkin, Marina and Silberstein, Mark},
title = {Eleos: ExitLess OS Services for SGX Enclaves},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064219},
doi = {10.1145/3064176.3064219},
abstract = {Intel Software Guard extensions (SGX) enable secure and trusted execution of user code in an isolated enclave to protect against a powerful adversary. Unfortunately, running I/O-intensive, memory-demanding server applications in enclaves leads to significant performance degradation. Such applications put a substantial load on the in-enclave system call and secure paging mechanisms, which turn out to be the main reason for the application slowdown. In addition to the high direct cost of thousands-of-cycles long SGX management instructions, these mechanisms incur the high indirect cost of enclave exits due to associated TLB flushes and processor state pollution.We tackle these performance issues in Eleos by enabling exit-less system calls and exit-less paging in enclaves. Eleos introduces a novel Secure User-managed Virtual Memory (SUVM) abstraction that implements application-level paging inside the enclave. SUVM eliminates the overheads of enclave exits due to paging, and enables new optimizations such as sub-page granularity of accesses.We thoroughly evaluate Eleos on a range of microbenchmarks and two real server applications, achieving notable system performance gains. memcached and a face verification server running in-enclave with Eleos, achieves up to 2.2\texttimes{} and 2.3\texttimes{} higher throughput respectively while working on datasets up to 5\texttimes{} larger than the enclave's secure physical memory.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {238–253},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064177,
author = {Goodman, Daniel and Varisteas, Georgios and Harris, Tim},
title = {Pandia: comprehensive contention-sensitive thread placement},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064177},
doi = {10.1145/3064176.3064177},
abstract = {Pandia is a system for modeling the performance of in-memory parallel workloads. It generates a description of a workload from a series of profiling runs, and combines this with a description of the machine's hardware to model the workload's performance over different thread counts and different placements of those threads.The approach is "comprehensive" in that it accounts for contention at multiple resources such as processor functional units and memory channels. The points of contention for a workload can shift between resources as the degree of parallelism and thread placement changes. Pandia accounts for these changes and provides a close correspondence between predicted performance and actual performance. Testing a set of 22 benchmarks on 2 socket Intel machines fitted with chips ranging from Sandy Bridge to Haswell we see median differences of 1.05\% to 0\% between the fastest predicted placement and the fastest measured placement, and median errors of 8\% to 4\% across all placements.Pandia can be used to optimize the performance of a given workload---for instance, identifying whether or not multiple processor sockets should be used, and whether or not the workload benefits from using multiple threads per core. In addition, Pandia can be used to identify opportunities for reducing resource consumption where additional resources are not matched by additional performance---for instance, limiting a workload to a small number of cores when its scaling is poor.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {254–269},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064178,
author = {Volckaert, Stijn and Coppens, Bart and De Sutter, Bjorn and De Bosschere, Koen and Larsen, Per and Franz, Michael},
title = {Taming Parallelism in a Multi-Variant Execution Environment},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064178},
doi = {10.1145/3064176.3064178},
abstract = {Exploit mitigations, by themselves, do not stop determined and well-resourced adversaries from compromising vulnerable software through memory corruption. Multi-variant execution environments (MVEEs) add additional assurance by executing multiple, diversified copies (variants) of the same program in lockstep while monitoring their behavior for signs of attacks (divergence). While executing multiple copies of the same program requires additional computational resources, modern MVEEs run many workloads at near-native speed and can detect adversaries before they leak secrets or achieve persistence on the host system.Multi-threaded programs are challenging to execute in lockstep by an MVEE. If the threads in a set of variants are not scheduled in the exact same order, the variants will diverge from each other in terms of the system calls they make. While benign, such divergence undermines the MVEEs ability detect divergence caused by malicious program inputs. To address this problem, we developed an MVEE-specific synchronization scheme that lets us execute a set of multithreaded variants in lockstep without causing benign divergence. Our fully-fledged MVEE runs the PARSEC 2.1 and SPLASH-2x parallel benchmarks (with four worker threads per variant) with a slowdown of less than 15\% relative to unprotected execution. Addressing this longstanding compatibility issue makes MVEEs a viable defense for a far greater range of realistic workloads.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {270–285},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064180,
author = {Teabe, Boris and Nitu, Vlad and Tchana, Alain and Hagimont, Daniel},
title = {The lock holder and the lock waiter pre-emption problems: nip them in the bud using informed spinlocks (I-Spinlock)},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064180},
doi = {10.1145/3064176.3064180},
abstract = {In native Linux systems, spinlock's implementation relies on the assumption that both the lock holder thread and lock waiter threads cannot be preempted. However, in a virtualized environment, these threads are scheduled on top of virtual CPUs (vCPU) that can be preempted by the hypervisor at any time, thus forcing lock waiter threads on other vCPUs to busy wait and to waste CPU cycles. This leads to the well-known Lock Holder Preemption (LHP) and Lock Waiter Preemption (LWP) issues.In this paper, we propose I-Spinlock (for Informed Spinlock), a new spinlock implementation for virtualized environments. Its main principle is to only allow a thread to acquire a lock if and only if the remaining time-slice of its vCPU is sufficient to enter and leave the critical section. This is possible if the spinlock primitive is aware (informed) of its time-to-preemption (by the hypervisor).We implemented I-Spinlock in the Xen virtualization system. We show that our solution is compliant with both para-virtual and hardware virtualization modes. We performed extensive performance evaluations with various reference benchmarks and compared our solution to previous solutions. The evaluations demonstrate that I-Spinlock outperforms other solutions, and more significantly when the number of core increases.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {286–297},
numpages = {12},
keywords = {multi-core, scheduler, spinlocks, virtual machine},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064186,
author = {Alam, Mohammad Mejbah ul and Liu, Tongping and Zeng, Guangming and Muzahid, Abdullah},
title = {SyncPerf: Categorizing, Detecting, and Diagnosing Synchronization Performance Bugs},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064186},
doi = {10.1145/3064176.3064186},
abstract = {Despite the obvious importance, performance issues related to synchronization primitives are still lacking adequate attention. No literature extensively investigates categories, root causes, and fixing strategies of such performance issues. Existing work primarily focuses on one type of problems, while ignoring other important categories. Moreover, they leave the burden of identifying root causes to programmers. This paper first conducts an extensive study of categories, root causes, and fixing strategies of performance issues related to explicit synchronization primitives. Based on this study, we develop two tools to identify root causes of a range of performance issues. Compare with existing work, our proposal, SyncPerf, has three unique advantages. First, SyncPerf's detection is very lightweight, with 2.3\% performance overhead on average. Second, SyncPerf integrates information based on callsites, lock variables, and types of threads. Such integration helps identify more latent problems. Last but not least, when multiple root causes generate the same behavior, SyncPerf provides a second analysis tool that collects detailed accesses inside critical sections and helps identify possible root causes. SyncPerf discovers many unknown but significant synchronization performance issues. Fixing them provides a performance gain anywhere from 2.5\% to 42\%. Low overhead, better coverage, and informative reports make SyncPerf an effective tool to find synchronization performance bugs in the production environment.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {298–313},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064203,
author = {Dice, Dave},
title = {Malthusian Locks},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064203},
doi = {10.1145/3064176.3064203},
abstract = {Applications running in modern multithreaded environments are sometimes overthreaded. The excess threads do not improve performance, and in fact may act to degrade performance via scalability collapse, which can manifest even when there are fewer ready threads than available cores. Often, such software also has highly contended locks. We leverage the existence of such locks by modifying the lock admission policy so as to intentionally limit the number of distinct threads circulating over the lock in a given period. Specifically, if there are more threads circulating than are necessary to keep the lock saturated (continuously held), our approach will selectively cull and passivate some of those excess threads. We borrow the concept of swapping from the field of memory management and impose concurrency restriction (CR) if a lock suffers from contention. The resultant admission order is unfair over the short term but we explicitly provide long-term fairness by periodically shifting threads between the set of passivated threads and those actively circulating. Our approach is palliative, but is often effective at avoiding or reducing scalability collapse, and in the worst case does no harm. Specifically, throughput is either unaffected or improved, and unfairness is bounded, relative to common test-and-set locks which allow unbounded bypass and starvation1. By reducing competition for shared resources, such as pipelines, processors and caches, concurrency restriction may also reduce overall resource consumption and improve the overall load carrying capacity of a system.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {314–327},
numpages = {14},
keywords = {Concurrency, admission control, admission order, caches, contention, fairness, locks, multicore, mutexes, mutual exclusion, scheduling, spinning, synchronization, threads},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064183,
author = {Fonseca, Pedro and Zhang, Kaiyuan and Wang, Xi and Krishnamurthy, Arvind},
title = {An Empirical Study on the Correctness of Formally Verified Distributed Systems},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064183},
doi = {10.1145/3064176.3064183},
abstract = {Recent advances in formal verification techniques enabled the implementation of distributed systems with machine-checked proofs. While results are encouraging, the importance of distributed systems warrants a large scale evaluation of the results and verification practices.This paper thoroughly analyzes three state-of-the-art, formally verified implementations of distributed systems: Iron-Fleet, Verdi, and Chapar. Through code review and testing, we found a total of 16 bugs, many of which produce serious consequences, including crashing servers, returning incorrect results to clients, and invalidating verification guarantees. These bugs were caused by violations of a wide-range of assumptions on which the verified components relied. Our results revealed that these assumptions referred to a small fraction of the trusted computing base, mostly at the interface of verified and unverified components. Based on our observations, we have built a testing toolkit called PK, which focuses on testing these parts and is able to automate the detection of 13 (out of 16) bugs.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {328–343},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064195,
author = {Chothia, Zaheer and Liagouris, John and Dimitrova, Desislava and Roscoe, Timothy},
title = {Online Reconstruction of Structural Information from Datacenter Logs},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064195},
doi = {10.1145/3064176.3064195},
abstract = {Well-run datacenter application architectures are heavily instrumented to provide detailed traces of messages and remote invocations. Reconstructing user sessions, call graphs, transaction trees, and other structural information from these messages, a process known as sessionization, is the foundation for a variety of diagnostic, profiling, and monitoring tasks essential to the operation of the datacenter.We present the design and implementation of a system which processes log streams at gigabits per second and reconstructs user sessions comprising millions of transactions per second in real time with modest compute resources, while dealing with clock skew, message loss, and other real-world phenomena that make such a task challenging. Our system is based on the Timely Dataflow framework for low latency, data-parallel computation, and we demonstrate its utility with a number of use-cases and traces from a large, operational, mission-critical enterprise data center.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {344–358},
numpages = {15},
keywords = {Data Parallelism, Resource Attribution, Sessionization, Streaming Log Analytics, Trace Trees},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064206,
author = {Ding, Ning and Hu, Y. Charlie},
title = {GfxDoctor: A Holistic Graphics Energy Profiler for Mobile Devices},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064206},
doi = {10.1145/3064176.3064206},
abstract = {Graphics is one of the major energy drain sources in smartphone apps. To optimize the app graphics energy, however, developers face the challenge of highly complex graphics rendering process, which involves multiple system layers including the app, the framework, the GPU, and the asynchronous interactions among them. Current diagnostic tools can profile the resource usage from certain layers, but fall short in stitching together profiling information across all the layers which is needed to provide developers with the visual effect-energy tradeoff at the app source-code level.In this paper, we design and implement a holistic graphics energy diagnosis tool, GfxDoctor1, that helps developers to systematically diagnose energy inefficiencies in app graphics at the app source-code level, by precisely quantifying (1) the visual effect of each UI update, and (2) the aggregate energy drain spent in traversing the entire frame rendering stack due to each UI update. GfxDoctor overcomes three challenges faced in deriving per-UI-update visual effect and energy accounting, asynchrony across system layers, UI update batching, and "black-box" GPU, with two key techniques -- lightweight view-frame-ID-based information flow tracking, and OpenGL record-and-replay plus frame diffing. We show the effectiveness of GfxDoctor by profiling a randomly sampled set of 30 popular Android apps which reveals three types of graphics energy bugs happening in 8 out of the 30 apps. Removing these bugs reduces the app energy drain by 46\% to 90\%.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {359–373},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064212,
author = {Chen, Ang and Haeberlen, Andreas and Zhou, Wenchao and Loo, Boon Thau},
title = {One Primitive to Diagnose Them All: Architectural Support for Internet Diagnostics},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064212},
doi = {10.1145/3064176.3064212},
abstract = {Today, network operators are increasingly playing the role of part-time detectives: they must routinely diagnose intricate problems and malfunctions, e.g., routing or performance issues, and they must often perform forensic investigations of past misbehavior, e.g., intrusions or cybercrimes. However, the current Internet architecture offers little direct support for them. A variety of solutions have been proposed, but each solution tends to address only one specific problem. Moreover, each solution proposes a different fix that is incompatible with the others, which complicates deployment.In this paper, we make the observation that most of the existing solutions share a common "functional core", which suggests that it may be possible to add a single primitive to the Internet architecture that can support a wide variety of diagnostic and forensic tasks. We then present one specific candidate that we call secure packet provenance (SPP). We show that SPP is easy to add to the current architecture, that it can be implemented efficiently in both software and hardware, and that it can be used to approximate (and sometimes surpass) the capabilities offered by a variety of existing diagnostic and forensic systems.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {374–388},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064205,
author = {Boos, Kevin and Vecchio, Emilio Del and Zhong, Lin},
title = {A Characterization of State Spill in Modern Operating Systems},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064205},
doi = {10.1145/3064176.3064205},
abstract = {Understanding and managing the propagation of states in operating systems has become an intractable problem due to their sheer size and complexity. Despite modularization efforts, it remains a significant barrier to many contemporary computing goals: process migration, fault isolation and tolerance, live update, software virtualization, and more. Though many previous OS research endeavors have achieved these goals through ad-hoc, tedious methods, we argue that they have missed the underlying reason why these goals are so challenging: state spill.State spill occurs when a software entity's state undergoes lasting changes as a result of a transaction from another entity. In order to increase awareness of state spill and its harmful effects, we conduct a thorough study of modern OSes and contribute a classification of design patterns that cause state spill. We present StateSpy, an automated tool that leverages cooperative static and runtime analysis to detect state spill in real software entities. Guided by StateSpy, we demonstrate the presence of state spill in 94\% of Android system services. Finally, we analyze the harmful impacts of state spill and suggest alternative designs and strategies to mitigate them.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {389–404},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064211,
author = {van der Kouwe, Erik and Nigade, Vinod and Giuffrida, Cristiano},
title = {DangSan: Scalable Use-after-free Detection},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064211},
doi = {10.1145/3064176.3064211},
abstract = {Use-after-free vulnerabilities due to dangling pointers are an important and growing threat to systems security. While various solutions exist to address this problem, none of them is sufficiently practical for real-world adoption. Some can be bypassed by attackers, others cannot support complex multithreaded applications prone to dangling pointers, and the remainder have prohibitively high overhead. One major source of overhead is the need to synchronize threads on every pointer write due to pointer tracking.In this paper, we present DangSan, a use-after-free detection system that scales efficiently to large numbers of pointer writes as well as to many concurrent threads. To significantly reduce the overhead of existing solutions, we observe that pointer tracking is write-intensive but requires very few reads. Moreover, there is no need for strong consistency guarantees as inconsistencies can be reconciled at read (i.e., object deallocation) time. Building on these intuitions, DangSan's design mimics that of log-structured file systems, which are ideally suited for similar workloads. Our results show that DangSan can run heavily multithreaded applications, while introducing only half the overhead of previous multithreaded use-after-free detectors.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {405–419},
numpages = {15},
keywords = {Dangling pointers, LLVM, use-after-free},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064216,
author = {Pomonis, Marios and Petsios, Theofilos and Keromytis, Angelos D. and Polychronakis, Michalis and Kemerlis, Vasileios P.},
title = {kR^X: Comprehensive Kernel Protection against Just-In-Time Code Reuse},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064216},
doi = {10.1145/3064176.3064216},
abstract = {The abundance of memory corruption and disclosure vulnerabilities in kernel code necessitates the deployment of hardening techniques to prevent privilege escalation attacks. As more strict memory isolation mechanisms between the kernel and user space, like Intel's SMEP, become commonplace, attackers increasingly rely on code reuse techniques to exploit kernel vulnerabilities. Contrary to similar attacks in more restrictive settings, such as web browsers, in kernel exploitation, non-privileged local adversaries have great flexibility in abusing memory disclosure vulnerabilities to dynamically discover, or infer, the location of certain code snippets and construct code-reuse payloads. Recent studies have shown that the coupling of code diversification with the enforcement of a "read XOR execute" (R^X) memory safety policy is an effective defense against the exploitation of userland software, but so far this approach has not been applied for the protection of the kernel itself.In this paper, we fill this gap by presenting kR^X: a kernel hardening scheme based on execute-only memory and code diversification. We study a previously unexplored point in the design space, where a hypervisor or a super-privileged component is not required. Implemented mostly as a set of GCC plugins, kR^X is readily applicable to the x86-64 Linux kernel and can benefit from hardware support (e.g., MPX on modern Intel CPUs) to optimize performance. In full protection mode, kR^X incurs a low runtime overhead of 4.04\%, which drops to 2.32\% when MPX is available.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {420–436},
numpages = {17},
keywords = {Code diversification, Execute-only memory},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064217,
author = {Koning, Koen and Chen, Xi and Bos, Herbert and Giuffrida, Cristiano and Athanasopoulos, Elias},
title = {No Need to Hide: Protecting Safe Regions on Commodity Hardware},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064217},
doi = {10.1145/3064176.3064217},
abstract = {As modern 64-bit x86 processors no longer support the segmentation capabilities of their 32-bit predecessors, most research projects assume that strong in-process memory isolation is no longer an affordable option. Instead of strong, deterministic isolation, new defense systems therefore rely on the probabilistic pseudo-isolation provided by randomization to "hide" sensitive (or safe) regions. However, recent attacks have shown that such protection is insufficient; attackers can leak these safe regions in a variety of ways.In this paper, we revisit isolation for x86-64 and argue that hardware features enabling efficient deterministic isolation do exist. We first present a comprehensive study on commodity hardware features that can be repurposed to isolate safe regions in the same address space (e.g., Intel MPX and MPK). We then introduce MemSentry, a framework to harden modern defense systems with commodity hardware features instead of information hiding. Our results show that some hardware features are more effective than others in hardening such defenses in each scenario and that features originally conceived for other purposes (e.g., Intel MPX for bounds checking) are surprisingly efficient at isolating safe regions compared to their software equivalent (i.e., SFI).},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {437–452},
numpages = {16},
keywords = {hardware features, information hiding, isolation, software fault isolation},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064196,
author = {Voron, Gauthier and Thomas, Ga\"{e}l and Qu\'{e}ma, Vivien and Sens, Pierre},
title = {An interface to implement NUMA policies in the Xen hypervisor},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064196},
doi = {10.1145/3064176.3064196},
abstract = {While virtualization only introduces a small overhead on machines with few cores, this is not the case on larger ones. Most of the overhead on the latter machines is caused by the Non-Uniform Memory Access (NUMA) architecture they are using. In order to reduce this overhead, this paper shows how NUMA placement heuristics can be implemented inside Xen. With an evaluation of 29 applications on a 48-core machine, we show that the NUMA placement heuristics can multiply the performance of 9 applications by more than 2.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {453–467},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064204,
author = {Hsu, Terry Ching-Hsiang and Br\"{u}gner, Helge and Roy, Indrajit and Keeton, Kimberly and Eugster, Patrick},
title = {NVthreads: Practical Persistence for Multi-threaded Applications},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064204},
doi = {10.1145/3064176.3064204},
abstract = {Non-volatile memory technologies, such as memristor and phase-change memory, will allow programs to persist data with regular memory instructions. Liberated from the overhead to serialize and deserialize data to storage devices, programs can aim for high performance and still be crash fault-tolerant. Unfortunately, to leverage non-volatile memory, existing systems require hardware changes or extensive program modifications.We present NVthreads, a programming model and runtime that adds persistence to existing multi-threaded C/C++ programs. NVthreads is a drop-in replacement for the pthreads library and requires only tens of lines of program changes to leverage non-volatile memory. NVthreads infers consistent states via synchronization points, uses the process memory to buffer uncommitted changes, and logs writes to ensure a program's data is recoverable even after a crash. NVthreads' page level mechanisms result in good performance: applications that use NVthreads can be more than 2\texttimes{} faster than state-of-the-art systems that favor fine-grained tracking of writes. After a failure, iterative applications that use NVthreads gain speedups by resuming execution.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {468–482},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064214,
author = {Alistarh, Dan and Leiserson, William and Matveev, Alexander and Shavit, Nir},
title = {Forkscan: Conservative Memory Reclamation for Modern Operating Systems},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064214},
doi = {10.1145/3064176.3064214},
abstract = {The problem of efficient concurrent memory reclamation in unmanaged languages such as C or C++ is one of the major challenges facing the parallelization of billions of lines of legacy code. Garbage collectors for C/C++ can be inefficient; thus, programmers are often forced to use finely-crafted concurrent memory reclamation techniques. These techniques can provide good performance, but require considerable programming effort to deploy, and have strict requirements, allowing the programmer very little room for error.In this work, we present Forkscan, a new conservative concurrent memory reclamation scheme which is fully automatic and surprisingly scalable. Forkscan's semantics place it between automatic garbage collectors (it requires the programmer to explicitly retire nodes before they can be reclaimed), and concurrent memory reclamation techniques (as it does not assume that nodes are completely unlinked from the data structure for correctness). Forkscan's implementation exploits these new semantics for efficiency: we leverage parallelism and optimized implementations of signaling and copy-on-write in modern operating systems to efficiently obtain and process consistent snapshots of memory that can be scanned concurrently with the normal program operation.Empirical evaluation on a range of classical concurrent data structure microbenchmarks shows that Forkscan can preserve the scalability of the original code, while maintaining an order of magnitude lower latency than automatic garbage collection, and demonstrating competitive performance with finely crafted memory reclamation techniques.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {483–498},
numpages = {16},
keywords = {Memory Management, Synchronization},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064215,
author = {Memaripour, Amirsaman and Badam, Anirudh and Phanishayee, Amar and Zhou, Yanqi and Alagappan, Ramnatthan and Strauss, Karin and Swanson, Steven},
title = {Atomic In-place Updates for Non-volatile Main Memories with Kamino-Tx},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064215},
doi = {10.1145/3064176.3064215},
abstract = {Data structures for non-volatile memories have to be designed such that they can be atomically modified using transactions. Existing atomicity methods require data to be copied in the critical path which significantly increases the latency of transactions. These overheads are further amplified for transactions on byte-addressable persistent memories where often the byte ranges modified for data structure updates are significantly smaller compared to the granularity at which data can be efficiently copied and logged. We propose Kamino-Tx that provides a new way to perform transactional updates on non-volatile byte-addressable memories (NVM) without requiring any copying of data in the critical path. Kamino-Tx maintains an additional copy of data off the critical path to achieve atomicity. But in doing so Kamino-Tx has to overcome two important challenges of safety and minimizing NVM storage overhead. We propose a more dynamic approach to maintaining the additional copy of data to reduce storage overheads. To further mitigate the storage overhead of using Kamino-Tx in a replicated setting, we develop Kamino-Tx-Chain, a variant of Chain Replication where replicas perform in-place updates and do not maintain data copies locally; replicas in Kamino-Tx-Chain leverage other replicas as copies to roll back or forward for atomicity. Our results show that using Kamino-Tx increases throughput by up to 9.5x for unreplicated systems and up to 2.2x for replicated settings.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {499–512},
numpages = {14},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064190,
author = {Rogora, Daniele and Papalini, Michele and Khazaei, Koorosh and Margara, Alessandro and Carzaniga, Antonio and Cugola, Gianpaolo},
title = {High-Throughput Subset Matching on Commodity GPU-Based Systems},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064190},
doi = {10.1145/3064176.3064190},
abstract = {Large-scale information processing often relies on subset matching for data classification and routing. Examples are publish/subscribe and stream processing systems, database systems, social media, and information-centric networking. For instance, an advanced Twitter-like messaging service where users might follow specific publishers as well as specific topics encoded as tag sets must join a stream of published messages with the users and their preferred tag sets so that the user tag set is a subset of the message tags.Subset matching is an old but also notoriously difficult problem. We present TagMatch, a system that solves this problem by taking advantage of a hybrid CPU/GPU stream processing architecture. TagMatch targets large-scale applications with thousands of matching operations per seconds against hundreds of millions of tag sets. We evaluate TagMatch on an advanced message streaming application, with very positive results both in absolute terms and in comparison with existing systems. As a notable example, our experiments demonstrate that TagMatch running on a single, commodity machine with two GPUs can easily sustain the traffic throughput of Twitter even augmented with expressive tag-based selection.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {513–526},
numpages = {14},
keywords = {GPU-based processing, Subset matching, message selection and dissemination},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064191,
author = {Maass, Steffen and Min, Changwoo and Kashyap, Sanidhya and Kang, Woonhak and Kumar, Mohan and Kim, Taesoo},
title = {Mosaic: Processing a Trillion-Edge Graph on a Single Machine},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064191},
doi = {10.1145/3064176.3064191},
abstract = {Processing a one trillion-edge graph has recently been demonstrated by distributed graph engines running on clusters of tens to hundreds of nodes. In this paper, we employ a single heterogeneous machine with fast storage media (e.g., NVMe SSD) and massively parallel coprocessors (e.g., Xeon Phi) to reach similar dimensions. By fully exploiting the heterogeneous devices, we design a new graph processing engine, named Mosaic, for a single machine. We propose a new locality-optimizing, space-efficient graph representation---Hilbert-ordered tiles, and a hybrid execution model that enables vertex-centric operations in fast host processors and edge-centric operations in massively parallel coprocessors.Our evaluation shows that for smaller graphs, Mosaic consistently outperforms other state-of-the-art out-of-core engines by 3.2-58.6x and shows comparable performance to distributed graph engines. Furthermore, Mosaic can complete one iteration of the Pagerank algorithm on a trillion-edge graph in 21 minutes, outperforming a distributed disk-based engine by 9.2\texttimes{}.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {527–543},
numpages = {17},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064194,
author = {Chatzopoulos, Georgios and Guerraoui, Rachid and Harris, Tim and Trigonakis, Vasileios},
title = {Abstracting Multi-Core Topologies with MCTOP},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064194},
doi = {10.1145/3064176.3064194},
abstract = {Portability and efficiency are usually antagonists in multi-core computing. In order to develop efficient code, one needs to take into account the topology of the target multi-cores (e.g., for locality). This clearly hampers code portability. In this paper, we show that you can have the cake and eat it too.We introduce MCTOP, an abstraction of multi-core topologies augmented with important low-level hardware information, such as memory bandwidths and communication latencies. We show how to automatically generate MCTOP using libmctop, our library that leverages the determinism of cache-coherence protocols to infer the topology of multi-cores using only latency measurements.MCTOP enables developers to accurately and portably define high-level performance optimization policies. We illustrate several such policies through four examples: (i-ii) thread placement in OpenMP and in a MapReduce library, (iii) a topology-aware mergesort algorithm, as well as (iv) automatic backoff schemes for locks. We illustrate the portability of these optimizations on five processors from Intel, AMD, and Oracle, with low effort.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {544–559},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064218,
author = {Papadimitriou, Antonis and Narayan, Arjun and Haeberlen, Andreas},
title = {DStress: Efficient Differentially Private Computations on Distributed Data},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064218},
doi = {10.1145/3064176.3064218},
abstract = {In this paper, we present DStress, a system that can efficiently perform computations on graphs that contain confidential data. DStress assumes that the graph is physically distributed across many participants, and that each participant only knows a small subgraph; it protects privacy by enforcing tight, provable limits on how much each participant can learn about the rest of the graph.We also study one concrete instance of this problem: measuring systemic risk in financial networks. Systemic risk is the likelihood of cascading bankruptcies -- as, e.g., during the financial crisis of 2008 -- and it can be quantified based on the dependencies between financial institutions; however, the necessary data is highly sensitive and cannot be safely disclosed. We show that DStress can implement two different systemic risk models from the theoretical economics literature. Our experimental evaluation suggests that DStress can run the corresponding computations in about five hours, whereas a na\"{\i}ve approach could take several decades.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {560–574},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064181,
author = {Yang, Youngseok and Kim, Geon-Woo and Song, Won Wook and Lee, Yunseong and Chung, Andrew and Qian, Zhengping and Cho, Brian and Chun, Byung-Gon},
title = {Pado: A Data Processing Engine for Harnessing Transient Resources in Datacenters},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064181},
doi = {10.1145/3064176.3064181},
abstract = {Datacenters are under-utilized, primarily due to unused resources on over-provisioned nodes of latency-critical jobs. Such idle resources can be used to run batch data analytic jobs to increase datacenter utilization, but these transient resources must be evicted whenever latency-critical jobs require them again. Resource evictions often lead to cascading recomputations, which is usually handled by checkpointing intermediate results on stable storages of eviction-free reserved resources. However, checkpointing has major shortcomings in its substantial overhead of transferring data back and forth. In this work, we step away from such approaches and focus on observing the job structure and the relationships between computations of the job. We carefully mark the computations that are most likely to cause a large number of recomputations upon evictions, to run them reliably using reserved resources. This lets us retain corresponding intermediate results effortlessly without any additional checkpointing. We design Pado, a general data processing engine, which carries out our idea with several optimizations that minimize the number of additional reserved nodes. Evaluation results show that Pado outperforms Spark 2.0.0 by up to 5.1\texttimes{}, and checkpoint-enabled Spark by up to 3.8\texttimes{}.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {575–588},
numpages = {14},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064182,
author = {Harlap, Aaron and Tumanov, Alexey and Chung, Andrew and Ganger, Gregory R. and Gibbons, Phillip B.},
title = {Proteus: agile ML elasticity through tiered reliability in dynamic resource markets},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064182},
doi = {10.1145/3064176.3064182},
abstract = {Many shared computing clusters allow users to utilize excess idle resources at lower cost or priority, with the proviso that some or all may be taken away at any time. But, exploiting such dynamic resource availability and the often fluctuating markets for them requires agile elasticity and effective acquisition strategies. Proteus aggressively exploits such transient revocable resources to do machine learning (ML) cheaper and/or faster. Its parameter server framework, AgileML, efficiently adapts to bulk additions and revocations of transient machines, through a novel 3-stage active-backup approach, with minimal use of more costly non-transient resources. Its BidBrain component adaptively allocates resources from multiple EC2 spot markets to minimize average cost per work as transient resource availability and cost change over time. Our evaluations show that Proteus reduces cost by 85\% relative to non-transient pricing, and by 43\% relative to previous approaches, while simultaneously reducing runtimes by up to 37\%.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {589–604},
numpages = {16},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064185,
author = {Agache, Alexandru and Ionescu, Mihai and Raiciu, Costin},
title = {CloudTalk: Enabling Distributed Application Optimisations in Public Clouds},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064185},
doi = {10.1145/3064176.3064185},
abstract = {Clouds offer an opaque I/O API to their customers: details of the underlying resources (network topology, disk drives) or their current load are kept hidden. Tenants can profile the I/O performance in their VMs and optimise accordingly, but the side effect is increased load. Certain cloud providers try to discourage profiling by enforcing strict I/O isolation, at the cost of reduced utilisation in the average case. In this paper we challenge this status quo and propose CloudTalk, an API that allows tenants to communicate with the cloud provider and receive hints used to optimise their workloads.We have built a distributed implementation of CloudTalk that scales to hundreds of machines and provides significant performance benefits in many cases. Further, we have implemented changes to Hadoop and HDFS that use CloudTalk to decide which machines to use for task placement and replica selection. Our experiments in a local cluster and on Amazon EC2 show that CloudTalk helps improve performance by as much as two times for a wide range of scenarios.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {605–619},
numpages = {15},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}

@inproceedings{10.1145/3064176.3064220,
author = {Wang, Cheng and Urgaonkar, Bhuvan and Gupta, Aayush and Kesidis, George and Liang, Qianlin},
title = {Exploiting Spot and Burstable Instances for Improving the Cost-efficacy of In-Memory Caches on the Public Cloud},
year = {2017},
isbn = {9781450349383},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3064176.3064220},
doi = {10.1145/3064176.3064220},
abstract = {In order to keep the costs of operating in-memory storage on the public cloud low, we devise novel ideas and enabling modeling and optimization techniques for combining conventional Amazon EC2 instances with the cheaper spot and burstable instances. Whereas a naturally appealing way of using failure-prone spot instances is to selectively store unpopular ("cold") content, we show that a form of "hot-cold mixing" across regular and spot instances might be more cost-effective. To overcome performance degradation resulting from spot instance revocations, we employ a highly available passive backup using the recently emergent burstable instances. We show how the idiosyncratic resource allocations of burstable instances make them ideal candidates for such a backup. We implement all our ideas in an EC2-based memcached prototype. Using simulations and live experiments on our prototype, we show that (i) our hot-cold mixing, informed by our modeling of spot prices, helps improve cost savings by 50-80\% compared to only using regular instances, and (ii) our burstable-based backup helps reduce performance degradation during spot revocation, e.g., the 95\% latency during failure recovery improves by 25\% compared to a backup based on regular instances.},
booktitle = {Proceedings of the Twelfth European Conference on Computer Systems},
pages = {620–634},
numpages = {15},
keywords = {burstable instance, in-memory caches, public cloud, spot instance},
location = {Belgrade, Serbia},
series = {EuroSys '17}
}