We study if replicated storage systems effectively utilize the caches embedded within each replica. Our study reveals that existing systems manage the embedded caches in each replica in silos, leading to significant cache redundancy across replicas and consequently low performance. To address this problem, we introduce logically disaggregated cache (Ldc), a new approach to managing caches in replicated storage systems. Ldc disaggregates the embedded caches from the replicas to form a single, logical cache. Ldc then allows any replica to access any part of the logical cache, which reduces redundancy caused by reads. Because writes pollute all caches, Ldc quickly demotes written objects to limit redundancy caused by writes. Ldc, however, realizes that reducing redundancy may hurt performance in some cases and thus employs an online analyzer to strike a balance between cache redundancy and coverage. We implement Ldc in three systems: an eventually-consistent KV store, a strongly-consistent KV store, and a production database. Using microbenchmarks, macrobenchmarks, and real-world traces, we show that the Ldc versions perform significantly better than the original systems (e.g., 2.6× to 5.4× higher throughput in the eventually-consistent KV store under YCSB).

Randomized controlled trials are often run in settings with many subpopulations that may have differential benefits from the treatment being evaluated. We consider the problem of sample selection, i.e., whom to enroll in a randomized trial, such as to optimize welfare in a heterogeneous population. We formalize this problem within the minimax-regret framework, and derive optimal sample-selection schemes under a variety of conditions. Using data from a COVID-19 vaccine trial, we also highlight how different objectives and decision rules can lead to meaningfully different guidance regarding optimal sample allocation.

Privilege separation (privsep) is an effective technique for improving software’s security, but privsep involves decomposing software into components and assigning them different privileges. This is often laborious and error-prone. This paper contributes the following for applying privsep to C software: (1) a portable, lightweight, and distributed runtime library that abstracts externally-enforced compartment isolation; (2) an abstract compartmentalization model of software for reasoning about privsep; and (3) a privsep-aware Clang-based tool for code analysis and semi-automatic software transformation to use the runtime library. The evaluation spans 19 compartmentalizations of third-party software and examines: Security: 4 CVEs in widely-used software were rendered unexploitable; Approximate Effort Saving: on average, the synthesis-to-annotation code ratio was greater than 11.9 (i.e., 10 × lines of code were generated for each annotation); and Overhead: execution-time overhead was less than 2%, and memory overhead was linear in the number of compartments.

Analysing software and networks can be done using established tools, such as debuggers and packet analysers, but using established tools to analyse network software is difficult and impractical because of the sheer detail the tools present and the performance overheads they typically impose. This makes it difficult to precisely diagnose performance anomalies in network software to identify their causes (is it a DoS attack or a bug?) and determine what needs to be fixed.We present Flowdar: a practical tool for analysing software traces to produce intuitive summaries of network software behaviour by abstracting unimportant details and demultiplexing traces into different sessions' subtraces. Flowdar can use existing state-of-the-art tracing tools for lower overhead during trace gathering for offline analysis. Using Flowdar we can drill down when diagnosing performance anomalies without getting overwhelmed in detail or burdening the system being observed.We show that Flowdar can be applied to existing real-world software and can digest complex behaviour into an intuitive visualisation.

Dexterous multi-fingered robotic hands can perform a wide range of manipulation skills, making them an appealing component for general-purpose robotic manipulators. However, such hands pose a major challenge for autonomous control, due to the high dimensionality of their configuration space and complex intermittent contact interactions. In this work, we propose deep reinforcement learning (deep RL) as a scalable solution for learning complex, contact rich behaviors with multi-fingered hands. Deep RL provides an end-to-end approach to directly map sensor readings to actions, without the need for task specific models or policy classes. We show that contact-rich manipulation behavior with multi-fingered hands can be learned by directly training with model-free deep RL algorithms in the real world, with minimal additional assumption and without the aid of simulation. We learn to perform a variety of tasks on two different low-cost hardware platforms entirely from scratch, and further study how the learning can be accelerated by using a small number of human demonstrations. Our experiments demonstrate that complex multi-fingered manipulation skills can be learned in the real world in about 4-7 hours for most tasks, and that demonstrations can decrease this to 2-3 hours, indicating that direct deep RL training in the real world is a viable and practical alternative to simulation and model-based control. https:// sites.google.com/view/deeprl-handmanipulation.

The recent networking paradigm shifts towards the virtualization and softwarization of network functions, controls, and applications that are promising; they optimize costs and processes while bringing new value to the infrastructures. However, the centralized reliability management in softwarization architecture poses both scalability and latency challenges. In this paper, we design and build a novel topology-aware network reliability management framework that enhances the efficiency of network discovery (Link Layer Discovery Protocol (LLDP)) mechanisms and introduces a three-tier-based algorithm that the controller utilizes to calculate the LLDP-discovery frequency. A novel impact based per target LLDP-discovery approach enables fast failure detection and recovery for the important targets. A prototype is implemented on Cisco's OpenDayLight (ODL). Extensive Mininet experiment results validate that the tier-based LLDP message algorithm enables effective decision making tools for the network reliability management framework.

The virtualization and softwareization of network functions, controls, and applications are promising as they optimize costs and processes while bringing new value to the network infrastructures. However, the centralized reliability management over the complex softwareized network poses both scalability and latency challenges on the failure recovery process. In this paper, we propose a Network Architecture-aware Reliability Management Schemes (NetAware) to efficiently orchestrate different reliability monitoring mechanisms over SDN network architecture and synchronize the control messages among different controllers and applications. NetAware facilitates many common reliability monitoring factors for the registered applications by analyzing both off-line and on-line network architecture information such as network topologies, virtualization, and protocols. NetAware consists of a High Availability Registration Platform (HARP) and a Topology Aware Reliability (TAR) discovery facilities. A prototype is implemented on Cisco's OpenDayLight (ODL).

Software-defined networking (SDN) is a softwarization technology of networks that can optimize processes and operation costs and bring new values to infrastructures. The issue of reliability, however, becomes more complex in SDN due to new and multi-lateral network domains, and poses many critical challenges on the existing network reliability mechanisms in order to achieve the same reliability services. In this paper, we first identify and illustrate reliability challenges in a control path network that lies between a control plane network and a data plane network to connect them through either an in-band SDN or an out-of-band traditional network. We then observe a number of distinctive control path reliability problems. Accordingly, we propose and develop a control path management framework to enhance SDN reliability addressing the observed issues. It includes several control path reliability algorithms that enhance performance, network protocols that simplify management of control path reliability, as well as a novel control message classification and prioritization system that serves as a fundamental approach to improve scalability and then reliability for SDN. Recognizing the control path as a network and understanding its potential and practical reliability problems enable us to provide effective solutions that prior approaches fall short of. We validate our proposed management framework through extensive experiments through a real network system as well as numerical analyses.

Despite tremendous software quality assurance efforts made by network vendors, chastising software bugs is a difficult problem especially, for the network systems in operation. Recent trends towards softwarization and opensourcing of network functions, protocols, controls, and applications tend to cause more software bug problems and pose many critical challenges to handle them. Although many traditional redundancy recovery mechanisms are adopted to the softwarized systems, software bugs cannot be resolved with them due to unexpected failure behavior. Furthermore, they are often bounded by common mode failure and common dependencies (CMFD). In this paper, we propose an online software bug detection, debugging, and isolation (BuDDI) middlebox architecture for software-defined network controllers. The BuDDI architecture consists of a shadow-controller based online debugging facility and a CMFD mitigation module in support of a seamless heterogeneous controller failover. Our proof-of-concept implementation of BuDDI is on the top of OpenVirtex by using Ryu and Pox controllers and verifies that the heterogeneous controller switchover does not cause any additional performance overhead.