Correct concurrent programs are difficult to write; when multiple threads mutate shared data, they may lose writes, corrupt data, or produce erratic program behavior. While many of the data-race issues with concurrency can be avoided by the placing of locks throughout the code, these often serialize program execution, and can significantly slow down performance-critical applications. Programmers also make mistakes, and often forget locks in less-executed code paths, which leads to programs that misbehave only in rare situations. Rust is a recent programming language from Mozilla that attempts to solve these intertwined issues by detecting data-races at compile time. Rust's type system encodes a data-structure's ability to be shared between threads in the type system, which in turn allows the compiler to reject programs where threads directly mutate shared state without locks or other protection mechanisms. In this work, we examine how this aspect of Rust's type system impacts the development and refinement of a concurrent data structure, as well as its ability to adapt to situations where correctness is guaranteed by lower-level invariants (e.g., in lock-free algorithms) that are not directly expressible in the type system itself. We detail the implementation of a concurrent lock-free hashmap in order to describe these traits of the Rust language. Our code is publicly available at this https URL and is one of the fastest concurrent hashmaps for the Rust language, which leads to mitigating bottlenecks in concurrent programs.

© 2019 USENIX Association USENIX is a registered trademark of the USENIX Association. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. USENIX acknowledges all trademarks herein. Where those designations appear in this publication and USENIX is aware of a trademark claim, the designations have been printed in caps or initial caps.

We introduce partially-stateful data-flow, a new streaming data-flow model that supports eviction and reconstruction of data-flow state on demand. By avoiding state explosion and supporting live changes to the data-flow graph, this model makes data-flow viable for building long-lived, low-latency applications, such as web applications. Our implementation, Noria, simplifies the backend infrastructure for read-heavy web applications while improving their performance.A Noria application supplies a relational schema and a set of parameterized queries, which Noria compiles into a data-flow program that pre-computes results for reads and incrementally applies writes. Noria makes it easy to write high-performance applications without manual performance tuning or complex-to-maintain caching layers. Partial statefulness helps Noria limit its in-memory state without prior data-flow systems' restriction to windowed state, and helps Noria adapt its data-flow to schema and query changes while on-line. Unlike prior data-flow systems, Noria also shares state and computation across related queries, eliminating duplicate work.On a real web application's queries, our prototype scales to 5× higher load than a hand-optimized MySQL baseline. Noria also outperforms a typical MySQL/memcached stack and the materialized views of a commercial database. It scales to tens of millions of reads and millions of writes per second over multiple servers, outperforming a state-of-the-art streaming data-flow system.

Xylem is a database design that targets readheavy web applications. It materializes indexed query results to speed up reads, and automatically updates these cached results as writes arrive. Realized naively, this approach would incur significant memory overhead, especially when queries are similar, or when some results are rarely accessed. Xylem introduces two key techniques novel to streaming data-flow systems to overcome this: partial materialization, and reuse of shared operators and state. Using these techniques Xylem efficiently handles query set changes at runtime with minimal downtime, allowing applications to evolve over time. Experiments show that Xylem outperforms state-of-the-art systems, and adapts to new query sets while reads and writes remain live. 1. Research Problem and Motivation An ideal storage system would provide the read performance of a key-value cache with the convenience and flexibility of relational queries. To emulate this ideal, web applications often supplement their database (DB) with fast in-memory caches (e.g., memcached [20]). The durable, transactional DB offers a relational query interface to developers [5], and the cache efficiently serves pre-computed query results [23]. However, this two-tier construction comes at a price. First, the cache and the DB must now be coordinated: the application must invalidate entries in the cache on writes, and recompute query results on cache misses. This requires complex and error-prone techniques to ensure correct application semantics and avoid severe performance collapses [23]. Second, it lacks flexibility: adding new queries or changing the schema requires either discarding the cache and migrating the system via planned downtime, or implementing complex manual migrations [27]. Since web application queries and schemas can change multiple times per week [7, 9, 25], this poses a major headache for developers. Xylem combines and extends ideas from databases and streaming data-flow systems to address these challenges. It transparently constructs and maintains a fast cache of pre-computed query results, supports relational queries, and allows online, backwards-compatible migrations to new schemas and queries. To provide these features, Xylem must overcome several intertwined problems: the space overhead of maintaining many cached query results can easily become prohibitive, existing techniques for updating cached results reads Xylem Joint dynamic data-flow graph

In principle, the web should provide the perfect stage for user-generated content, allowing users to share their data seamlessly with other users across services and applications. In practice, the web fragments a user’s data over many sites, each exposing only limited APIs for sharing. This paper describes Oort, a new cloud storage system that organizes data primarily by user rather than by application or web site. Oort allows users to choose which web software to use with their data and which other users to share it with, while giving applications powerful tools to query that data. Users rent space from providers that cooperate to provide a global, federated, general-purpose storage system. To support large-scale, multi-user applications such as Twitter and e-mail, Oort provides global queries that find and combine data from relevant users across all providers. Oort makes global query execution efficient by recognizing and merging similar queries issued by many users’ application instances, largely eliminating the per-user factor in the global complexity of queries. Our evaluation predicts that an Oort implementation could handle traffic similar to that seen by Twitter using a hundred cooperating Oort servers, and that applications with other sharing patterns, like e-mail, can also be executed efficiently.

In principle, the web should provide the perfect stage for user-generated content, allowing users to share their data seamlessly with other users across services and applications. In practice, the web fragments a user's data over many sites, each exposing only limited APIs for sharing. This paper describes Oort, a new cloud storage system that organizes data primarily by user rather than by application or web site. Oort allows users to choose which web software to use with their data and which other users to share it with, while giving applications powerful tools to query that data. Users rent space from providers that cooperate to provide a global, federated, general-purpose storage system. To support large-scale, multi-user applications such as Twitter and e-mail, Oort provides global queries that find and combine data from relevant users across all providers. Oort makes global query execution efficient by recognizing and merging similar queries issued by many users' application instances, largely eliminating the per-user factor in the global complexity of queries. Our evaluation predicts that an Oort implementation could handle traffic similar to that seen by Twitter using a hundred cooperating Oort servers, and that applications with other sharing patterns, like e-mail, can also be executed efficiently.

User-generated content is becoming increasingly common on the Web, but current web applications isolate their users' data, enabling only restricted sharing and cross-service integration. We believe users should be able to share their data seamlessly between their applications and with other users. To that end, we propose Amber, an architecture that decouples users' data from applications, while providing applications with powerful global queries to find user data. We demonstrate how multi-user applications, such as e-mail, can use these global queries to efficiently collect and monitor relevant data created by other users. Amber puts users in control of which applications they use with their data and with whom it is shared, and enables a new class of applications by removing the artificial partitioning of users' data by application.

i n recent years, there has been renewed interest within the mobile and wireless networking communities in addressing problems related to the sensing of signals using multi-antenna radios, such as MIMO Wi-Fi access points. Recent examples include systems that localize RFID tags [8] and Wi-Fi devices [6, 9], enhance Wi-Fi security [10], and passive radar systems that pinpoint human movements [1, 2, 4]. These systems, and others, share an important common thread: they all rely on phased array signal processing; a set of techniques that makes various comparisons between the radio signals received from each of the antennas of a radio. Phased array processing has been applied in weather and military radar, seismology, and astronomy to great benefit, but its application to indoor and outdoor wireless and mobile communications presents new challenges and opportunities for novel system designs, as the above work demonstrates. While the aforementioned work demonstrates useful applications of phased array signal processing in mobile wireless local-area network designs, many of these systems rely on expensive, specialized hardware, which prohibits wide-scale deployment. Meanwhile, Wi-Fi is becoming ubiquitous, with many Wi-Fi access points (APs) being equipped with multiple network interface cards (NICs), each with multiple antennas [11]. If these widely deployed APs could be converted into miniature phased array receivers, signal processing systems could be run truly

Signal processing on antenna arrays has received much recent attention in the mobile and wireless networking research communities, with array signal processing approaches addressing the problems of human movement detection, indoor mobile device localization, and wireless network security. However, there are two important challenges inherent in the design of these systems that must be overcome if they are to be of practical use on commodity hardware. First, phase differences between the radio oscillators behind each antenna can make readings unusable, and so must be corrected in order for most techniques to yield high-fidelity results. Second, while the number of antennas on commodity access points is usually limited, most array processing increases in fidelity with more antennas. These issues work in synergistic opposition to array processing: without phase offset correction, no phase-difference array processing is possible, and with fewer antennas, automatic correction of these phase offsets becomes even more challenging. We present Phaser, a system that solves these intertwined problems to make phased array signal processing truly practical on the many WiFi access points deployed in the real world. Our experimental results on three- and five-antenna 802.11-based hardware show that 802.11 NICs can be calibrated and synchronized to a 20° median phase error, enabling inexpensive deployment of numerous phase-difference based spectral analysis techniques previously only available on costly, special-purpose hardware.

Signal processing on antenna arrays has received much recent attention in the mobile and wireless networking research communities, with array signal processing approaches addressing the problems of human movement detection, indoor mobile device localization, and wireless network security. However, there are two important challenges inherent in the design of these systems that must be overcome if they are to be of practical use on commodity hardware. First, phase differences between the radio oscillators behind each antenna can make readings unusable, and so must be corrected in order for most techniques to yield high-fidelity results. Second, while the number of antennas on commodity access points is usually limited, most array processing increases in fidelity with more antennas. These issues work in synergistic opposition to array processing: without phase offset correction, no phase-difference array processing is possible, and with fewer antennas, automatic correction of these phase offsets becomes even more challenging. We present Phaser, a system that solves these intertwined problems to make phased array signal processing truly practical on the many WiFi access points deployed in the real world. Our experimental results on three- and five-antenna 802.11-based hardware show that 802.11 NICs can be calibrated and synchronized to a 20° median phase error, enabling inexpensive deployment of numerous phase-difference based spectral analysis techniques previously only available on costly, special-purpose hardware.

Concolic execution systems allow developers to verify that invariants in their applications are not violated no matter what input is given by a user. This was demonstrated in Lab 3, where the Z3 solver was used to find inputs that would trigger inconsistencies in Zoobar balances. Unfortunately, the lab’s framework is written specifically for Zoobar, and would therefore not work for other applications without substantial modifications. Invariant checking is useful for a wide range of applications, and thus we decided to make our 6.858 final project building a generic concolic execution interface for any Django-based web application.

Signal processing on antenna arrays has received much recent attention in the mobile and wireless networking research communities, with array signal processing approaches addressing the problems of human movement detection, indoor mobile device localization, and wireless network security. However, there are three important challenges inherent in the design of these systems that must be overcome if they are to be of practical use on commodity hardware. First, phase differences between the radio oscillators behind each antenna can make readings unusable, and so must be corrected in order for most techniques to yield high-fidelity results. Second, in many deployments, access points are elevated to maximize coverage, introducing height differences between the mobile device and antenna array (usually the access point) that can skew results. Third, while the number of antennas on commodity access points is usually limited, most array processing increases in fidelity with more antennas. Worse still, these issues work in synergistic opposition to array processing: without phase offset correction, no phase-difference array processing is possible, and unknown height differences between mobiles and access points make automatic correction of these phase offsets even more challenging. Furthermore, limited numbers of antennas result in poor fidelity, complicating both problems further. We present ArrayPhaser, a system that solves these intertwined problems to make phased array signal processing truly practical on the many WiFi access points deployed in the real world. Our experimental results on threeand five-antenna 802.11-based hardware show that 802.11 NICs can be calibrated and synchronized to a tolerance of 15◦ median phase error, enabling inexpensive deployment of numerous phase-difference based spectral analysis techniques previously only available on costly, special-purpose hardware. This material is based on work supported by the European Research Council under Grant No. 279976. ArrayPhaser: Enabling Signal Processing on WiFi Access Points Jon Gjengset Graeme McPhillips Kyle Jamieson

Model checking and model-based test generation are both well proven techniques for improving the quality assurance process for software. Unfortunately, constructing the necessary models requires expertise beyond that held by most QA teams. Training these teams in abstract model construction would require much in terms of time, cost and effort, and might not be a viable option for many businesses when held up against the potential gains. This paper explores the process of constructing a model solely from a pre-existing test suite of an application. More specifically, it examines the viability of automating this process to give QA teams a tool for automatically enhancing their test suites. Due to the time constraints of this project, the goal of this paper is only to examine the requirements for such automatic generation, and not to actually implement any tools to achieve this.