Index: Operating Systems and Distributed Systems

Operating Systems and Distributed Systems Glossary.

TitleDocumentTextual SummaryComicsAnimationPrized Entry
Automating Dependence-Aware Parallelization of Machine Learning Training on Distributed Shared Memory
GRNN: Low-Latency and Scalable RNN Inference on GPUs
Deferred Runtime Pipelining for contentious multicore software transactions
Replayable Execution Optimized for Page Sharing for a Managed Runtime Environment
Grapple: A Graph System for Static Finite-State Property Checking of Large-Scale Systems Code
Multiverse: Compiler-Assisted Management of Dynamic Variability in Low-Level System Software
Efficient, Consistent Distributed Computation with Predictive Treaties
Resource Deflation: A New Approach For Transient Resource Reclamation
Serving Mobile Apps – A Slice at a Time
Keeping Master Green at Scale
Runtime Object Lifetime Profiler for Latency Sensitive Big Data Applications
Efficient and Safe Network Updates with Suffix Causal Consistency
I Sent It: Where Does Slow Data Go to Wait?
The Case For In-Network Computing On Demand
FlyMC: Highly Scalable Testing of Complex Interleavings in Distributed Systems
Scalable RDMA RPC on Reliable Connection with Efficient Resource Sharing
Managing Tail Latency in Datacenter-Scale File Systems Under Production Constraints
Project Almanac: A Time-Traveling Solid-State Drive
Compact NUMA-aware Locks
LockDoc: Trace-Based Analysis of Locking in the Linux Kernel
CoPart: Coordinated Partitioning of Last-Level Cache and Memory Bandwidth for Fairness-Aware Workload Consolidation on Commodity Servers
SkyBridge: Fast and Secure Inter-Process Communication for Microkernels
Make the Most out of Last Level Cache in Intel Processors
When eXtended Para-Virtualization (XPV) Meets NUMA
AnDrone: Virtual Drone Computing in the Cloud
Per Application Power Delivery
Time Protection: the Missing OS Abstraction
BB: Booting Booster for Consumer Electronics with Modern OS
vScale: Automatic and Efficient Processor Scaling for SMP Virtual Machines
On the Capacity of Thermal Covert Channels in Multicores
A High Performance File System for Non-Volatile Main Memory
The Linux Scheduler: A Decade of Wasted Cores
Shared Address Translation Revisited
Exploiting Variability for Energy Optimization of Parallel Program
zExpander: a Key-value Cache with both High Performance and Fewer Misses
Increasing Large-Scale Data Center Capacity by Statistical Power Control
HAFT: Hardware-Assisted Fault Tolerance
A Study of Modern Linux API Usage and Compatibility: What to Support When You’re Supporting
Practical Condition Synchronization for Transactional Memory
Hardware Read-Write Lock Elision
POSIX Abstractions in Modern Operating Systems: The Old, the New, and the Missing
Yoda: A Highly Available Layer-7 Load Balancer
Efficient Queue Management for Cluster Scheduling
Parallel Sections: Scaling System-Level Data-Structures
TetriSched: global rescheduling with adaptive plan-ahead in dynamic heterogeneous clusters
An Efficient Page-level FTL to Optimize Address Translation in Flash Memory
Application-Assisted Live Migration of Virtual Machines with Java Applications
Deriving and Comparing Deduplication Techniques Using a Model-Based Classification
SpotCheck: Designing a Derivative IaaS Cloud on the Spot Market
Extensible Distributed Coordination
Guaranteeing Deadlines for Inter-Datacenter Transfers
Guardat: Enforcing data policies at the storage layer
Hare: a file system for non-cache-coherent multicores
High-Performance Determinism with Total Store Order Consistency
Large scale cluster management at Google with Borg
MALT: Distributed Data-Parallelism for existing ML applications
An In-Memory Object Caching Framework with Adaptive Load Balancing
Process-level Power Estimation in VM-based Systems
Scaling Concurrent Log-Structured Data Stores
Simba: Tunable End-to-End Data Consistency for Mobile Apps
Synapse: A Microservices Architecture for Heterogeneous-Database Web Applications
Taming uncertainty in distributed systems with help from the network
Verifiable Differential Privacy
Visigoth Fault Tolerance
Chronos: A Graph Engine for Temporal Graph Analysis,
DynMR: Dynamic MapReduce with ReduceTask Interleaving and MapTask Backfilling
Reconciling High Server Utilization and Sub-millisecond Quality-of-Service,
DIBS: Just-in-time Congestion Mitigation for Data Centers
TAQ: Enhancing Fairness and Performance Predictability in Small Packet Regimes
Practical Techniques to Obviate Setuid-to-Root Binaries
Rex: Replication at the Speed of Multi-core
Relational access to Unix kernel data structures
Caching in Video CDNs: Building Strong Lines of Defense
Aerie: Flexible File-System Interfaces to Storage-Class Memory
System Software for Persistent Memory
TESLA: Temporally Enhanced System Logic Assertions
T-Rex: A Dynamic Race Detection Tool for C/C++ Transactional Memory Applications,
Archiving Cold Data in Warehouses with Clustered Network Coding
Callisto: Co-Scheduling Parallel Runtime Systems
Using Restricted Transactional Memory to Build a Scalable In-Memory Database
Algorithmic Improvements for Fast Concurrent Cuckoo Hashing
TimeStream: Reliable Stream Computation in the Cloud
Optimus: A Dynamic Rewriting Framework for Execution Plans of Data-Parallel Computation
BlinkDB: Queries with Bounded Errors and Bounded Response Times on Very Large Data
IFDB: Decentralized Information Flow Control for Databases
Resolving the conflict between generality and plausibility in verified computation
Conversion: Multi-Version Concurrency Control for Main Memory Segments
Adaptive Parallelization of Web Search
Whose Cache Line Is It Anyway? Operating System Support for Live Detection and Repair of False Sharing
Mizan: A System for Dynamic Load Balancing in Large-scale Graph Processing
Presto: Distributed Machine Learning and Graph Processing with Sparse Matrices
RadixVM: Scalable address spaces for multithreaded applications
Composing OS extensions safely and efficiently with Bascule
Prefetching Mobile Ads: Can advertising systems afford it?
hClock: Hierarchical QoS for Packet Scheduling in a Hypervisor
Omega: flexible, scalable schedulers for large compute clusters
CPI2: CPU performance isolation for shared compute clusters
Language constructs and support systems for distributed computing
Distributed communication via global buffer
Language concepts for distributed processing of large arrays
Four combinators for concurrency
A distributed algorithm for detecting resource deadlocks in distributed systems
On-the-fly deadlock prevention
Synchronisation and recovery of actions
Data-dependent concurrency control and recovery (Extended Abstract)
An algorithm, for replicated directories
Decentralization of process nets with centralized control
Real-time programming and asynchronous message passing
Invited address solved problems, unsolved problems and non-problems in concurrency
Verification of multiprocess probabilistic protocols
A technique for proving liveness of communicating finite state machines with examples
Knowledge and common knowledge in a distributed environment
Asynchronous Byzantine consensus
Elections in the presence of faults
An asynchronous [(n – 1)/3]-resilient consensus protocol
Relations between concurrent-write models of parallel computation
SODA: A simplified operating system for distributed applications
Replicated procedure call
Efficient solutions to the replicated log and dictionary problems
A distributed algorithm for deadlock detection and resolution
A distributed algorithm for generalized deadlock detection
Symmetry and similarity in distributed systems
Fast distributed agreement (preliminary version)
Comparing how atomicity mechanisms support replication
Distributed version management for read-only actions (extended abstract)
Improvements in the time complexity of two message-optimal election algorithms
Parallel arithmetic with concurrent writes
Simple, efficient asynchronous parallel algorithms for maximization
Designing a global name service
Correctness conditions for highly available replicated databases
Highly available distributed services and fault-tolerant distributed garbage collection
Transaction commit in a realistic fault model
Distributing the power of a government to enhance the privacy of voters
Optimal message routing without complete routing tables
Incremental attribute evaluation in distributed language-based environments
Gap theorems for distributed computing
Protocols for dynamic vote reassignment
Efficient synchronization of multiprocessors with shared memory
Memory coherence in shared virtual memory systems
What processes know: Definitions and proof methods
Slowing sequential algorithms for obtaining fast distributed and parallel algorithms: maximum matchings
A hundred impossibility proofs for distributed computing
The intractability of bounded protocols for non-FIFO channels
Source to destination communication in the presence of faults
Knowledge, probability, and adversaries
The ambiguity of choosing
Sticky bits and universality of consensus
Efficient solution to the distributed mutual exclusion problem
Efficient parallel algorithms can be made robust
Efficient distributed recovery using message logging
A structural induction theorem for processes
Shared-memory vs. message-passing in an asynchronous distributed environment
Calling names in nameless networks
Fast isolation of arbitrary forwarding faults
Atomic snapshots of shared memory
The inhibition spectrum and the achievement of causal consistency
Lazy replication: exploiting the semantics of distributed services
Distributed variable server for atomic unification
Self-stabilizing extensions for message-passing systems
Token management schemes and random walks yield self-stabilizing mutual exclusion
Distributed control for PARIS
Principle for high speed network control: congestion-and deadlock-freeness, self-routing, and a single buffer per link
Cost-sensitive analysis of communication protocols
Reasoning about probabilistic algorithms
Time-and space-efficient randomized consensus
Sharing memory robustly in message-passing systems
Practical uses of synchronized clocks in distributed systems
Randomized wait-free concurrent objects (extended abstract)
Efficient parallel algorithms on restartable fail-stop processors
Resiliency of interactive distributed tasks (extended abstracts)
Optimal space distributed move-to-front lists
A theory of relaxed atomicity (extended abstract)
Real-time sequence transmission problem
The benefits of relaxing punctuality
Greedy packet scheduling on shortest paths (preliminary version)
Efficient deadlock-free routing
Knowledge in shared memory systems (preliminary version)
Exploiting locality in maintaining potential causality
Inconsistency and contamination (preliminary version)
Resource bounds for self stabilising message driven protocols
Unreliable failure detectors for asynchronous systems (preliminary version)
Distributed priority algorithms under one-bit-delay constraint
Connection-based communication in dynamic networks
Requirements for deadlock-free, adaptive packet routing
The slide mechanism with applications in dynamic networks
Computing with faulty shared memory
Concurrent counting
Optimal multi-writer multi-reader atomic register
Performing work efficiently in the presence of faults
Observing self-stabilization
The weakest failure detector for solving consensus
Improving fast mutual exclusion
Fast network decomposition
Leader election in complete networks
The impact of time on the session problem
The possibility and the complexity of achieving fault-tolerant coordination
Recent trends in experimental operating systems research
Issues and directions in scalable parallel computing
Atomic snapshots in O(n log n) operations
Fast deflection routing for packets and worms
Experiences with a model for parallel computation
Wait-free clock synchronization
Designing algorithms for distributed systems with partially synchronized clocks
A completeness theorem for a class of synchronization objects
Fast, scalable synchronization with minimal hardware support
Adaptive solutions to the mutual exclusion problem
On the space complexity of randomized synchronization
A lower bound on wait-free counting
Knowledge-oriented programming
Research issues in ubiquitous computing
Multimedia networking: applications and challenges
Making operations of concurrent data types fast
Delimiting the power of bounded size synchronization objects (extended abstract)
Wait-freedom vs. bounded wait-freedom in public data structures (extended abstract)
Contention—free complexity of shared memory algorithms
Using belief to reason about cache coherence
Mixed consistency: a model for parallel programming (extended abstract)
A checkpoint protocol for an entry consistent shared memory system
A performance evaluation of lock-free synchronization protocols
Using k-exclusion to implement resilient, scalable shared objects (extended abstract)
Disjoint-access-parallel implementations of strong shared memory primitives
Resilience of general interactive tasks
Potential function analysis of greedy hot-potato routing
Self-stabilization by counter flushing
Adaptive algorithms for PASO systems
Uniform actions in asynchronous distributed systems
Knowledge, timed precedence and clocks (preliminary report)
Proving time bounds for randomized distributed algorithms
Wait-freedom vs. t-resiliency and the robustness of wait-free hierarchies (extended abstract)
On the use of registers in achieving wait-free consensus
Consensus power makes (some) sense! (extended abstract)
Self-stabilizing algorithms for finding centers and medians of trees
Leader election in the presence of link failures (abstract)
The impact of synchronization on the session problem
Dynamic load sharing algorithm with a weighted load representation
Consistency and conformance in ODP (abstract)
Verification of a distributed algorithm (abstract)
Dynamic sets for search
Competitiveness in distributed algorithms
Simulating fail-stop in asynchronous distributed systems
On the memory overhead of distributed snapshots
Distributed pursuit-evasion: some aspects of privacy and security in distributed computing
Contention in counting networks
A case for NOW (networks of workstation)
Sub-linear distributed algorithms for sparse certificates and biconnected components
Faster computation on directed networks of automata
On distributed object checkpointing and recovery
On the relevance of communication costs of rollback-recovery protocols
More on t-resilience vs. wait-freedom (extended abstract)
Achieving independence efficiently and securely
Reasoning about meta level activities in open distributed systems
Knowledge-based programs
Formal semantics for expressing optimism: the meaning of HOPE
Formal verification of timed properties of randomized distributed algorithms
Long-lived renaming made fast
Lock-free linked lists using compare-and-swap
Optimal distributed algorithm for minimum spanning trees revisited
Fast distributed construction of k-dominating sets and applications
A modular measure of competitiveness for distributed algorithms
SuperStabilizing protocols for dynamic distributed systems
Self-stabilizing clock synchronization with Byzantine faults
The RAPID C++ environment (work in progress)
Architecture decisions for wide area applications
Prediction based task scheduling in distributed computing
A view-based approach to relaxing global serializability in a multidatabase system
A calculus for concurrent update (abstract)
Lazy-writer multivalued registers
Using lock-free objects in hard real-time applications
Complete implementations for shared memory consistency conditions
A logarithmic depth counting network
Load balancing networks
Atomicity in electronic commerce
Memory requirements for silent stabilization
Fault-containing self-stabilizing algorithms
About state recording in asynchronous computations
Minimizing access costs in replicated distributed systems
Trade-offs in implementing causal message logging protocols
Efficient message ordering in dynamic networks
An efficient recovery-based spin lock protocol for preemptive shared-memory multiprocessors
Characterization of message ordering specifications and protocols
Comparing primary-backup and state machines for crash failures
Synthesis of distributed control systems
Synthesis of concurrent systems for an atomic read/atomic write model of computation
Testing concurrent data structures
Memory requirement for routing in distributed networks
Optimal routing tables
Fast, long-lived renaming improved and simplified
The complexity of data mining on the Web
Efficient token-based control in rings
Efficient traffic laws for mobile robots—work in progress
Polylog randomized wait-free consensus
Asynchrony versus bulk-synchrony in QRQW PRAM models
Space-efficient construction of buffer-optimal 1-writer 1-reader multivalued atomic variable
Randomized adaptive video on demand
Distributed algorithms for sparse k-connectivity certificates
Randomness in private computations
Distributed pseudo-random bit generators—a new way to speed-up shared coin tossing
Early-stopping Terminating Reliable Broadcast protocol for general-omission failures
Baked potatoes: deadlock prevention via scheduling
Convergence complexity of optimistic rate based flow control algorithms (brief announcement)
Universal operations: unary versus binary
Space bounds for transactional synchronization
What critical algebraic property allows operations of concurrent abstract data types to be “fast”?
The role of data-race-free programs in recoverable DSM
Crash failures vs. crash + link failures
Crash failures can drive protocols to arbitrary states
Time and space lower bounds for non-blocking implementations (preliminary version)
Simple, fast, and practical non-blocking and blocking concurrent queue algorithms
A proof of a theorem in algebraic-topology by a distributed algorithm
Wait-free solvability via combinatorial topology
Simulation as an iterated task
On the decidability of distributed decision tasks
Counting networks are practically linearizable
How to be an efficient snoop, or the probe complexity of quorum systems (extended abstract)
Eventually-serializable data services
The strength of counting networks
Tight bounds on the cumulative profit of distributed voters
The offset problem
Fail-awareness in timed asynchronous systems
On the impossibility of group membership
Collective consistency work in progress
Impossibility of (repeated) reliable broadcast
A framework for partitionable membership service
Multi party computations: past and present
Internet support for wireless and mobile networking (tutorial)
Principles and patterns of high-performance and real-time distributed object computing (tutorial)
Maintaining authenticated communication in the presence of break-ins
Randomness vs. fault-tolerance
Relative liveness and behavior abstraction (extended abstract)
Dynamic voting for consistent primary components
Lazy consistency using loosely synchronized clocks
How useful is old information (extended abstract)?
Determining consensus numbers
On the power of shared object types to implement one-resilient Consensus
Disentangling multi-object operations (extended abstract)
A wait-free sorting algorithm
Efficiency of oblivious versus non-oblivious schedulers for optimistic, rate-based flow control (extended abstract)
Algorithmic problems in Internet research
High performance clusters: state of the art and challenges ahead
How to find it (abstract): research issues in distributed search
Distributed and parallel computing issues in data warehousing (abstract)
Compact routing schemes with low stretch factor (extended abstract)
Reconsidering fragmentation and reassembly
Competitive dynamic bandwidth allocation
Contention in balancing networks resolved (extended abstract)
Asynchronous group mutual exclusion (extended abstract)
Combining funnels: a new twist on an old tale…
Amortizing randomness in private multiparty computations
Universal service-providers for database private information retrieval (extended abstract)
Optimal efficiency of optimistic contract signing
The unified structure of consensus: a layered analysis approach
Unifying synchronous and asynchronous message-passing models
Round-by-round fault detectors (extended abstract): unifying synchrony and asynchrony
The message classification model
Reliable message delivery and conditionally-fast transactions are not possible without accurate clocks
Synthesis of fault-tolerant concurrent programs
A lower bound on the local time complexity of universal constructions
A tight lower bound for randomized synchronous consensus
A time complexity lower bound for randomized implementations of some shared objects
Consensus numbers of multi-objects
Persistent messages in local transactions
A dynamic view-oriented group communication service
Supporting quality of service in HTTP servers
The HIP protocol for hierarchical multicast routing
In-place reconstruction of delta compressed files
A polylog time wait-free construction for closed objects
Structured derivations of consensus algorithms for failure detectors
A consistent history link connectivity protocol
An error control scheme for large-scale multicast applications
The global efficiency of distributed, rate-based, flow control algorithms
Scalable best matching prefix lookups
Muteness detectors for consensus with Byzantine processes
Implementing and evaluating an eventually-serializable data service
k-stabilization of reactive tasks
Asynchronous time-adaptive self stabilization
Robust efficient distributed RSA-key generation
Probabilistic Byzantine quorum systems
Efficient evaluation of causality relations between nonatomic events
An agent-based architecture for building CORBA distributed systems
Responsiveness and consistency tradeoffs in interactive groupware
Propeties of the r-operators to insure termination of distributed computations
Optimal and efficient clock synchronization under drifting clocks
Analysis of timing-based mutual exclusion with random times
A simple local-spin group mutual exclusion algorithm
Rollback-dependency trackability: visible characterizations
Optimal locking integrated with operational transformation in distributed real-time group editors
Matching events in a content-based subscription system
Liveness-preserving simulation relations
Long-lived renaming made adaptive
Flash Mixing
Scalable concurrent priority queue algorithms
Wait-free synchronization in multiprogrammed systems: integrating priority-based and quantum-based scheduling
Sequentially consistent versus linearizable counting networks
Decentralized replicated-object protocols
Timed consistency for shared distributed objects
Comparison of initial conditions for distributed algorithms on anonymous networks
Computing anonymously with arbitrary knowledge
Backward consistency and sense of direction in advanced distributed systems
Memory space requirements for self-stabilizing leader election protocols
Optimal reactive k-stabilization: the case of mutual exclusion
A faster distributed algorithm for computing maximal matchings deterministically
Resource discovery in distributed networks
Fast set agreement in the presence of timing uncertainty
On k-set consensus problems in asynchronous systems
Mutable checkpoints: a new checkpointing approach for mobile computing systems
Delay-optimal quorum-based mutual exclusion for distributed systems
The HiMAT model for mobile agent applications
The sound of silence—guessing games for saving energy in mobile environment
Fundamental distributed protocols in mobile networks
External logging on a logical ring
A dynamic self-stabilizing algorithm for finding strongly connected components
Two classes of communication patterns
Optimal, distributed decision-making: the case of no communication
Using CSP to derive a sequentially consistent DSM system
Maintenance of a spanning tree in dynamic networks
Lower and upper bounds for attacks on authentication protocols
A design methodology for mobile distributed applications based on UNITY formalism and communication-closed layering
Distributed algorithms in TLA (abstract)
A middleware overview: goals, research issues, and coded examples (abstract)
Data communications vs. distributed computing (abstract)
How computer architecture trends may affect future distributed systems: from infiniBand clusters to inter-processor speculation (abstract)
Average-case analysis of greedy packet scheduling (extended astract)
Adaptive and efficient mutual exclusion (extended abstract)
Assigning labels in unknown anonymous networks (extended abstract)
Clock synchronization with faults and recoveries (extended abstract)
Garbage collection of timestamped data in Stampede
On the interconnection of causal memory systems
Distributed reconfiguration of metamorphic robot chains
1/k phase stamping for continuous shared data (extended abstract)
High performance adaptive middleware for CORBA-based systems
X-ability: a theory of replication
Self-stabilizing token circulation on asynchronous uniform unidirectional rings
Stable and fault-tolerant object allocation
Indulgent algorithms (preliminary version)
Fast deterministic consensus in a noisy environment
Toward a theory of maximally concurrent programs (shortened version)
Optimal implementation of the weakest failure detector for solving consensus (brief announcement)
Deterministic distributed resource discovery (brief announcement)
Fast protocol transition in a distributed environment (brief announcement)
The ABCD’s of Paxos
Implementing atomic objects in a dynamic environment
On beyond registers: wait-free readable objects
Computing almost shortest paths
Distributed MST for constant diameter graphs
On the generalized dining philosophers problem
A note on group mutual exclusion
Nearly optimal perfectly-periodic schedules
Compressed bloom filters
A hierarchy of conditions for consensus solvability
The concurrency hierarchy, and algorithms for unbounded concurrency
On scalable and efficient distributed failure detectors
Lock-free reference counting
Detecting distributed cycles of garbage in large-scale systems
Reliability and performance of hierarchical RAID with multiple controllers
Distributed multi-broadcast in unknown radio networks
Selective private function evaluation with applications to private statistics
Optimal scheduling for disconnected cooperation
Randomized shared queues
Dynamic input/output automata, a formal model for dynamic systems
A framework for semantic reasoning about Byzantine quorum systems
An efficient communication strategy for ad-hoc mobile networks
Correction: practical implementations of non-blocking synchronization primitives
Nonatomic mutual exclusion with local spinning
Space-optimal multi-writer snapshot objects are slow
Safe memory reclamation for dynamic lock-free objects using atomic reads and writes
The inherent price of indulgence
Competitive concurrent distributed queuing
Non-blocking timeout in scalable queue-based spin locks
Minimal replication cost for availability
Building secure file systems out of byzantine storage
Detectable byzantine agreement secure against faulty majorities
A highly concurrent group mutual l-exclusion algorithm0
Assignment-based partitioning in a condition monitoring system
Optimal plans for aggregation
General perfectly periodic scheduling
Sequential composition of protocols without simultaneous termination
Squirrel: a decentralized peer-to-peer web cache
Evaluating the running time of a communication round over the internet
How to wait when you are not going to block
Early stopping in global data computation
f-arrays: implementation and applications
Dynamic and self-stabilizing distributed matching
Working with mike on distributed computing theory, 1978–1992
Fischer’s cryptographic protocols
Compact roundtrip routing with topology-independent node names
Geometric ad-hoc routing: of theory and practice
Software transactional memory for dynamic-sized data structures
Split-ordered lists: lock-free extensible hash tables
Routing networks for distributed hash tables
Asynchronous resource discovery
Oblivious signature-based envelope
Scalable public-key tracing and revoking
Brief announcement: impossibility results for concurrent secure two-party computation
tight bounds for k-set agreement with limited-scope failure detectors
Proactive secure message transmission in asynchronous networks
Efficient reliable communication over partially authenticated networks
Brief announcement: extending SQL access control to derived and distributed data
A work-optimal deterministic algorithm for the asynchronous certified write-all problem
Performing work with asynchronous processors: message-delay-sensitive bounds
Adaptive and efficient abortable mutual exclusion
Automatic discovery of mutual exclusion algorithms
On using network attached disks as shared memory
A lattice-theoretic characterization of safety and liveness
Scaling properties of the Internet graph
Adapting to a reliable network path
Mechanism design for policy routing
Bringing practical lock-free synchronization to 64-bit applications
An almost non-blocking stack
Lock-free linked lists and skip lists
Lower bounds for adaptive collect and related objects
Efficient synchronous snapshots
Specification faithfulness in networks with rational nodes
On spectrum sharing games
Load balancing and locality in range-queriable data structures
Choosing a random peer
Compact routing on euclidian metrics
When graph theory helps self-stabilization
Efficient algorithms for constructing (1+,ε, β)-spanners in the distributed and streaming models
Tradeoffs between stretch factor and load balancing ratio in routing on growth restricted graphs
Efficient top-K query calculation in distributed networks
Byzantine disk paxos: optimal resilience with byzantine shared memory
On the design of distributed protocols from differential equations
How fast can a distributed atomic read be?
Signed quorum systems
A better wake-up in radio networks
A note on efficient aggregate queries in sensor networks
Computation in networks of passively mobile finite-state sensors
What cannot be computed locally!
Gradient clock synchronization
Communication-efficient leader election and consensus with limited link synchrony
The weakest failure detectors to solve certain fundamental problems in distributed computing
Group membership: a novel approach and the first single-round algorithm
Asynchronous group key exchange with failures
stretch between nearby peers
prefix hash tree
detecting malicious routers
a single enqueuer wait-free queue implementation
constraint-based synchronization and verification of concurrent programs
completing the lock-free dynamic cycle
spoofing prevention method
concurrent maintenance of rings
name-independent compact routing in trees
Trilix: a scalable unstructured lookup system for dynamic environments
virtual mobile nodes for mobile ad hoc networks
reconfigurable byzantine-fault-tolerant atomic memory
building an adaptive distributed web server system on the fly for handling web hotspots
Cataclysm: handling extreme overloads in internet services
RT oblivious erasure correcting
degree: optimal deterministic routing for P2P systems
efficient clustering in unstructured radio networks
on the round complexity of distributed consensus over synchronous networks
the synchronous condition-based consensus hierarchy
efficient implementation of a byzantine data storage system
Brief announcement: on the inherent cost of generic broadcast
Brief announcement: on the possibility of consensus in asynchronous systems with finite average response times
A topological characterization of weakness
Proof labeling schemes
Efficient dependency tracking for relevant events in shared-memory systems
Policy-hiding access control in open environment
Distance estimation and object location via rings of neighbors
On the locality of bounded growth
Skip-webs: efficient distributed data structures for multi-dimensional data sets
Efficient lookup on unstructured topologies
The price of selfish behavior in bilateral network formation
Facility location: distributed approximation
Primal-dual based distributed algorithms for vertex cover with semi-hard capacities
Faster communication in known topology radio networks
On reliable broadcast in a radio network
Maximal independent sets in radio networks
On selection problem in radio networks
Fast fault-tolerant agreement algorithms
The combined power of conditions and failure detectors to solve asynchronous set agreement
The weakest failure detector to solve nonuniform consensus
Routing complexity of faulty networks
Feedback control for router congestion resolution
Competitive weighted throughput analysis of greedy protocols on DAGs
Advanced contention management for dynamic software transactional memory
Efficient multi-word locking using randomization
Toward a theory of transactional contention managers
Stochastic analysis of distributed deadlock scheduling
Adaptive routing with stale information
Session details: Peer-to-peer
A scheme for load balancing in heterogenous distributed hash tablesCorrectness of a gossip based membership protocol
On the establishment of distinct identities in overlay networks
Feasibility and complexity of broadcasting with random transmission failures
Reliable broadcast in unknown fixed-identity networks
The art of multiprocessor programming
Century papers at the first quarter-century milestone
Distributed social systems
On the complexity of distributed graph coloring
Quorum placement in networks: minimizing network congestion
Distributed verification of minimum spanning trees
When selfish meets evil: byzantine players in a virus inoculation game
Routing without regret: on convergence to nash equilibria of regret-minimizing algorithms in routing games
Distributed computing meets game theory: robust mechanisms for rational secret sharing and multiparty computation
EquiCast: scalable multicast with selfish users
Grouped distributed queues: distributed queue, proportional share multiprocessor scheduling
Sketching asynchronous streams over a sliding window
Adversarial queuing on the multiple-access channel
Veracity radius: capturing the locality of distributed computations
Life is not a state-machine: the long road from research to production
Computing separable functions via gossip
Peer counting and sampling in overlay networks: random walk methods
On the topologies formed by selfish peers
Self-stabilizing byzantine agreement
Optimally efficient multi-valued byzantine agreement
Oracle size: a new measure of difficulty for communication tasks
Object location using path separators
Optimal-stretch name-independent compact routing in doubling metrics
Local approximation schemes for topology control
Single-scanner multi-writer snapshot implementations are fast!
An O(1) RMRs leader election algorithm
How fast can a very robust read be?An Ω (n log n) lower bound on the cost of mutual exclusion
Stably computable predicates are semilinear
Transactional contention management as a non-clairvoyant scheduling problem
Synchronizing without locks is inherently expensive
Towards a theory of transactional contention managers
The Akamai approach to achieving performance and reliability on the internet
SNZI: scalable NonZero indicators
Abortable and query-abortable objects and their efficient implementation
Time-optimal, space-efficient single-scanner snapshots & multi-scanner snapshots using CAS
Reconstructing approximate tree metrics
A randomized distributed algorithm for the maximal independent set problem in growth-bounded graphs
Improved sparse covers for graphs excluding a fixed minor
Compact routing with slack in low doubling dimension
Compact routing with slack
Towards fast decentralized construction of locality-aware overlay networks
On the complexity of greedy routing in ring-based peer-to-peer networks
Constructing scalable overlays for pub-sub with many topics
Efficient fork-linearizable access to untrusted shared memory
Truth in advertising: lightweight verification of route integrity
Countering web spam with credibility-based link analysis
Distributed approximate matching
Controller and estimator for dynamic networks
Broadcasting in udg radio networks with unknown topology
Communication in dynamic radio networks
Time-decaying sketches for sensor data aggregation
Summarizing data using bottom-k sketches
On the weakest failure detector ever
Tolerating corrupted communication
Optimal inter-object correlation when replicating for availability
Greedy distributed optimization of multi-commodity flows
Distributed network monitoring and multicommodity flows: a primal-dual approach
Network formation games with local coalitions
Bounded wait-free implementation of optimally resilient byzantine storage without (unproven) cryptographic assumptions
Towards the minimal synchrony for byzantine consensus
Remote storage with byzantine servers
Multicoordinated Paxos
From an intermittent rotating star to a leader
Practical private computation of vector addition-based functions
d-clock: distributed QoS in heterogeneous resource environments
Privatization techniques for software transactional memory and privatization in Delaunay triangulation
From causal to z-linearizable transactional memory
Sharpness, a tight condition for throughput scalability
An analysis of intention preservation in group editors
Minimizing the total cost of network measurements in a distributed manner: a primal-dual approach
Theory of BAR games
An algorithm composition scheme preserving monotonicity
A denial-of-service resistant DHT
SuperTrust: a secure and efficient framework for handling trust in super-peer netwNon-searchability of random scale-free graphsorks
Optimal atomic broadcast and multicast algorithms for wide area networks
DoS-resilient secure aggregation queries in sensor networks
Self-stabilizing counting in mobile sensor networks
Paxos made live: an engineering perspective
Beyond nash equilibrium: solution concepts for the 21st century
The internet is flat: a brief history of networking in the next ten years
Accountability for distributed systems
Distributed computation of the modeSublogarithmic distributed MIS algorithm for sparse graphs using nash-williams decomposition
Brahms: byzantine resilient random membership sampling
Improved compact routing schemes for dynamic trees
The forgiving tree: a self-healing distributed data structure
Flooding time in edge-Markovian dynamic graphs
Distributed algorithms for ultrasparse spanners and linear size skeletons
New combinatorial topology upper and lower bounds for renaming
Timeliness-based wait-freedom: a gracefully degrading progress condition
Lower bounds for randomized consensus under a weak adversary
Randomized consensus in expected O(n log n) individual work
Packet mode and QoS algorithms for buffered crossbar switches with FIFO queuing
The impact of randomization in smoothing networks
Optimizing data popularity conscious bloom filters
Distributed order scheduling and its application to multi-core dram controllers
OCD: obsessive consensus disorder (or repetitive consensus)
Forget him and keep on moving
On the internet delay space dimensionality
The asynchronous bounded-cycle model
Model checking transactional memory with spin
A fast distributed slicing algorithm
A dynamic exchange game
Our brothers’ keepers
Nearest-neighbor graphs on random point sets and their applications to sensor networks
Dynamic service assignment in mobile networks: the magma approach
Distributed averaging in the presence of a sparse cut
Quantum distributed consensus
Tight RMR lower bounds for mutual exclusion and other problems
Closing the complexity gap between mutual exclusion and FCFS mutual exclusion
Optimizing consistency checking for memory-intensive transactions
Transactional memory retry mechanisms
Efficient single phase unconditionally secure message transmission with optimum communication complexity
The power of simulation relations
The future of distributed computing: renaissance or reformation?
Refining the way to consensus
Memory models: a case for rethinking parallel languages and hardware
TCP/IP and OSI Interoperability with the X Window System
A Privilege Mechanism for UNIX System V Release 4 Operating Systems
The DIDS (Distributed Intrusion Detection System) Prototype
ifdef Considered Harmful, or Portability Experience with C News
Performance of a Parallel Network Backup Manager
Large Scale Porting through Parameterization
A Highly Available Lock Manager for HA-NFS
Mainframe Services from Gigabit-Networked Workstations
The Continuous Media File System
NeD: The Network Extensible Debugger
Regression Testing and Conformance Testing Interactive Programs
A Discipline of Error Handling
Virtual Window Systems: A New Approach to Supporting Concurrent Heterogeneous Windowing Systems
Tiled Virtual Memory for UNIX
InterNetNews: Usenet Transport for Internet Sites
A Scalable Implementation of Virtual Memory HAT Layer for Shared Memory Multiprocessor Machines
VNS Retriever: Querying MEDLINE over the Internet
TDBM: A DBM Library with Atomic Transactions
Cheap Mutual Exclusion
On Migrating a Distributed Application to a Multi-Threaded Environment
The Recovery Box: Using Fast Recovery to Provide High Availability in the UNIX Environment
Implementing Lightweight Threads
Beyond Multiprocessing: Multithreading the SunOS Kernel
File System Multithreading in System V Release 4 MP
Call Path Profiling of Monotonic Program Resources in UNIX
Computer System Performance Problem Detection Using Time Series Models
Design and Implementation of a Simulation The Restore-o-Mounter: The File Motel Revisited
Call Path Profiling of Monotonic Program Resources in UNIX
Computer System Performance Problem Detection Using Time Series Models
Design and Implementation of a Simulation Library Using Lightweight Processes
X Through the Firewall, and Other Application Relays
The Ferret Document Browser
LADDIS: The Next Generation in NFS File Server Benchmarking
Design and Implementation of a Multimedia Protocol Suite in a BSD UNIX Kernel
The Spring Nucleus: A Microkernel for Objects
“Stacking” Vnodes: A Progress Report
Anonymous RPC: Low-Latency Protection in a 64-Bit Address Space
Integrating Handwriting Recognition into UNIX
Optimizing UNIX Resource Scheduling for User Interaction
AudioFile: A Network-Transparent Audio Server
High Performance Dynamic Linking Through Caching
sfs: A Parallel File System for the CM-5
Adaptive Block Rearrangement Under UNIX
Objecting to Objects
Finding Similar Files in a Large File System
cql – A Flat File Database Query Language
GLIMPSE: A Tool to Search Through Entire File Systems
Drinking from the Firehose: Multicast USENET News
The refdbms Distributed Bibliographic Database System
Filesystem Daemons as Unifying Mechanism for Network Information Access
Concert/C: A Language for Distributed Programming
Concert/C: A Language for Distributed Programming
Tread Marks: Distributed Shared Memory on Standard Workstations and Operating Systems
Workstation Support for Real-Time Multimedia Communication
Experience and Results from Implementation of an ATM Socket Family
Efficient Packet Demultiplexing for Multiple Endpoints and Large Messages
Latency Analysis of TCP on an ATM Network
Improving UNIX Kernel and Networking Performance Using Profile Based Optimization
Memory Behavior for an X11 Window System
A Uniform Name Service for Spring’s UNIX Environment
ACID: A Debugger Built from a Language
File System Design for an NFS File Server Appliance
File System Design for an NFS File Server Appliance
Not Quite NFS, Soft Cache Consistency forNFS
A Quantitative Analysis of Disk Drive Power Management in Portable Computers
Thwarting the Power-Hungry Disk
A Usage Profile and Evaluation of a Wide-Area Distributed File System
Wux: UNIX Tools under Windows
An MS-DOS Filesystem for UNIX
An Overview of the NetWare Operating System
A New Object-oriented Programming Language: sh
The Old Man and the C
Key Management in an Encrypting File System
SNP: An Interface for Secure Network Programming
An Efficient Kernel-Based Implementation of POSIX Threads
The Slab Allocator: An Object-Caching Kernel
A Better Update Policy
Sawmill: A High Bandwidth Logging File System
Clue Tables: A Distributed, Dynamic-Binding Naming Mechanism
Optimistic Lookup of Whole NFS Paths in a Single Operation
Application-Controlled File Caching Policies
Resolving File Conflicts in the Ficus File System
Reducing File System Latency using a Predictive Approach
Operating System Support for Distributed Multimedia
Splicing UNIX into a Genome Mapping Laboratory
A Text Retrieval Package for the Unix Operating System
Probing TCP Implementations
Profiling and Tracing Dynamic Library Usage Via Interposition
Large Granularity Cache Coherence for Intermittent Connectivity
An Analysis of Trace Data for Predictive File Caching in Mobile Computing
Secure Short-Cut Routing for Mobile IP
Dynamic Vnodes – Design and Implementation
Union Mounts in 4.4BSD-Lite
Multi-resident AFS: An Adventure in Mass Storage
RAMA: Easy Access to a High-Bandwidth Massively Parallel File System
Implementing Real Time Packet Forwarding Policies Using Streams
Flexible and Safe Resolution of File Conflicts
OODCE: A C++ Framework for the OSF Distributed Computing Environment
Mach-US: Unix On Generic OS Object Servers
Events in an RPC Based Distributed System
Turning the AIX Operating System into an MP-capable OS
A Flash-Memory Based File System
TRON: Process-Specific File Protection for the UNIX Operating System
SIFT – a Tool for Wide-Area Information Dissemination
Performance Implications of Multiple Pointer Sizes
Idleness is Not Sloth
Optimizing the Performance of Dynamically-Linked Programs
Libckpt: Transparent Checkpointing under UNIX
DP: A Library for Building Portable, Reliable Distributed Applications
File System Logging versus Clustering: A Performance Comparison
Metadata Logging in an NFS Server
Heuristic Cleaning Algorithms in Log-Structured File Systems
The New Jersey Machine-Code Toolkit
ATOM: A Flexible Interface for Building High Performance Program Analysis Tools
Adaptable Binary Programs
Scalability in the XFS File System
A Comparison of FFS Disk Allocation Policies
AFRAID–A Frequently Redundant Array of Independent Disks
A Comparison of OS Extension Technologies
An Extensible Protocol Architecture for Application-Specific Networking
Linux Device Driver Emulation in Mach
Calliope: A Distributed, Scalable Multimedia Server
Simple Continuous Media Storage Server on Real-Time Mach
Eliminating Receive Livelock in an Interrupt-driven Kernel
Implementation of IPv6 in 4.4 BSD
Supporting Mobility in MosquitoNet
World Wide Web Cache Consistency
A Hierarchical Internet Object Cache
Tracking and Viewing Changes on the Web
Implementation of a Reliable Remote Memory Pager
Solaris MC: A Multi Computer OS
A New Approach to Distributed Memory Management in the Mach Microkernel
Fault Tolerance in a Distributed CHORUS/MiX System
FLIPC: A Low Latency Messaging System for Distributed Real Time Environments
An Analysis of Process and Memory Models to Support High-Speed Networking in a UNIX Environment
Zero-Copy TCP in Solaris
A Performance Comparison of UNIX Operating Systems on the Pentium
lmbench: Portable Tools for Performance Analysis
Cut-and-Paste File-Systems: Integrating Simulators and File-Systems
Process Labeled Kernel Profiling: A New Facility to Profile System Activities
Predicting Future File-System Actions From Prior Events
Transparent Fault Tolerance for Parallel Applications on Networks of Workstations
Why Use a Fishing Line When you Have a Net? An Adaptive Multicast Data Distribution Protocol
Scalability in the XFS File System
A Comparison of FFS Disk Allocation Policies
AFRAID–A Frequently Redundant Array of Independent Disks
A Comparison of OS Extension Technologies
An Extensible Protocol Architecture for Application-Specific Networking
Linux Device Driver Emulation in Mach
Calliope: A Distributed, Scalable Multimedia Server
Simple Continuous Media Storage Server on Real-Time Mach
Eliminating Receive Livelock in an Interrupt-driven Kernel
World Wide Web Cache Consistency
A Hierarchical Internet Object Cache
Tracking and Viewing Changes on the Web
Implementation of a Reliable Remote Memory Pager
Solaris MC: A Multi Computer OS
A New Approach to Distributed Memory Management in the Mach Microkernel
Fault Tolerance in a Distributed CHORUS/MiX System
FLIPC: A Low Latency Messaging System for Distributed Real Time Environments
An Analysis of Process and Memory Models to Support High-Speed Networking in a UNIX Environment
Zero-Copy TCP in Solaris
A Performance Comparison of UNIX Operating Systems on the Pentium
lmbench: Portable Tools for Performance Analysis
Process Labeled Kernel Profiling: A New Facility to Profile System Activities
Cut-and-Paste File-Systems: Integrating Simulators and File-Systems
Predicting Future File-System Actions From Prior Events
Transparent Fault Tolerance for Parallel Applications on Networks of Workstations
Why Use a Fishing Line When you Have a Net? An Adaptive Multicast Data Distribution Protocol
Measure, Then Build
The Design and Operation of CloudLab
Everyone Loves File: File Storage Service (FSS) in Oracle Cloud Infrastructure
Zanzibar: Google’s Consistent, Global Authorization System
IASO: A Fail-Slow Detection and Mitigation Framework for Distributed Storage Services
PARTISAN: Scaling the Distributed Actor Runtime
Unleashing the Power of Learning: An Enhanced Learning-Based Approach for Dynamic Binary Translation
Transactuations: Where Transactions Meet the Physical World
Not So Fast: Analyzing the Performance of WebAssembly vs. Native Code
Extension Framework for File Systems in User space
FlexGroup Volumes: A Distributed WAFL File System
EROFS: A Compression-friendly Readonly File System for Resource-scarce Devices
QZFS: QAT Accelerated Compression in File System for Application Agnostic and Cost Efficient Data Storage
Apache Nemo: A Framework for Building Distributed Dataflow Optimization Policies
Tangram: Bridging Immutable and Mutable Abstractions for Distributed Data Analytics
STRADS-AP: Simplifying Distributed Machine Learning Programming without Introducing a New Programming Model
SOPHIA: Online Reconfiguration of Clustered NoSQL Databases for Time-Varying Workloads
DistCache: Provable Load Balancing for Large-Scale Storage Systems with Distributed Caching
Protocol-Aware Recovery for Consensus-Based Storage
Orca: Differential Bug Localization in Large-Scale Services
LegoOS: A Disseminated, Distributed OS for Hardware Resource Disaggregation
libmpk: Software Abstraction for Intel Memory Protection Keys (Intel MPK)
LXDs: Towards Isolation of Kernel Subsystems
Effective Static Analysis of Concurrency Use-After-Free Bugs in Linux Device Drivers
JumpSwitches: Restoring the Performance of Indirect Branches In the Era of Spectre
The Semantics of Transactions and Weak Memory in x86, Power, ARM, and C++
Darwin: A Genomics Co-processor Provides up to 15,000X Acceleration on Long Read Assembly
Who Left Open the Cookie Jar? A Comprehensive Evaluation of Third-Party Cookie Policies
Multi-Queue Fair Queuing
BRAVO—Biased Locking for Reader-Writer Locks
Mitigating Asymmetric Read and Write Costs in Cuckoo Hashing for Storage Systems
NICA: An Infrastructure for Inline Acceleration of Network Applications
E3: Energy-Efficient Microservices on SmartNIC-Accelerated Servers
INSIDER: Designing In-Storage Computing System for Emerging High-Performance Drive
Cognitive SSD: A Deep Learning Engine for In-Storage Data Retrieval
SIMD-X: Programming and Processing of Graph Algorithms on GPUs
LUMOS: Dependency-Driven Disk-based Graph Processing
NeuGraph: Parallel Deep Neural Network Computation on Large Graphs
Pre-Select Static Caching and Neighborhood Ordering for BFS-like Algorithms on Disk-based Graph Engines
From Laptop to Lambda: Outsourcing Everyday Jobs to Thousands of Transient Functional Containers
Hodor: Intra-Process Isolation for High-Throughput Data Plane Libraries
A Retargetable System-Level DBT Hypervisor
MTS: Bringing Multi-Tenancy to Virtual Networking
StreamBox-TZ: Secure Stream Analytics at the Edge with TrustZone
CoSMIX: A Compiler-based System for Secure Memory Instrumentation and Execution in Enclaves
Secured Routines: Language-based Construction of Trusted Execution Environments
Supporting Security Sensitive Tenants in a Bare-Metal Cloud
Asynchronous I/O Stack: A Low-latency Kernel I/O Stack for Ultra-Low Latency SSDs
M³x: Autonomous Accelerators via Context-Enabled Fast-Path Communication
SmartDedup: Optimizing Deduplication for Resource-constrained Devices
Data Domain Cloud Tier: Backup here, backup there, deduplicated everywhere!
GAIA: An OS Page Cache for Heterogeneous Systems
Transkernel: Bridging Monolithic Kernels to Peripheral Cores
Detecting Asymmetric Application-layer Denial-of-Service Attacks In-Flight with FineLame
SemperOS: A Distributed Capability System
Pragh: Locality-preserving Graph Traversal with Split Live Migration
ElasticBF: Elastic Bloom Filter with Hotness Awareness for Boosting Read Performance in Large Key-Value Stores
SILK: Preventing Latency Spikes in Log-Structured Merge Key-Value Stores
Unification of Temporary Storage in the NodeKernel Architecture
Alleviating Garbage Collection Interference Through Spatial Separation in All Flash Arrays
Practical Erase Suspension for Modern Low-latency SSDs
Evaluating File System Reliability on Solid State Drives
Track-based Translation Layers for Interlaced Magnetic Recording
R2P2: Making RPCs first-class datacenter citizens
Your Coflow has Many Flows: Sampling them for Fun and Speed
PostMan: Rapidly Mitigating Bursty Traffic by Offloading Packet Processing
Lancet: A self-correcting Latency Measuring Tool
Pangolin: A Fault-Tolerant Persistent Memory Programming Library
Pisces: A Scalable and Efficient Persistent Transactional Memory
EdgeWise: A Better Stream Processing Engine for the Edge
Analysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training Workloads
Lessons and Actions: What We Learned from 10K SSD-Related Storage System Failures
Who’s Afraid of Uncorrectable Bit Errors? Online Recovery of Flash Errors with Distributed Redundancy
Dayu: Fast and Low-interference Data Recovery in Very-large Storage Systems
OPTR: Order-Preserving Translation and Recovery Design for SSDs with a Standard Block Device Interface
Optimizing CNN Model Inference on CPUs
Accelerating Rule-matching Systems with Learned Rankers
MArk: Exploiting Cloud Services for Cost-Effective, SLO-Aware Machine Learning Inference Serving
Cross-dataset Time Series Anomaly Detection for Cloud Systems
Blockchain in the Lens of BFT
Tributary: spot-dancing for elastic services with latency SLOs
FastTrack: Foreground App-Aware I/O Management for Improving User Experience of Android Smartphones
Mainstream: Dynamic Stem-Sharing for Multi-Tenant Video Processing
VideoChef: Efficient Approximation for Streaming Video Processing Pipelines
SOCK: Rapid Task Provisioning with Serverless-Optimized Containers
DynaMix: Dynamic Mobile Device Integration for Efficient Cross-device Resource Sharing
The Battle of the Schedulers: FreeBSD ULE vs. Linux CFS
The Design and Implementation of Hyperupcalls
AIQL: Enabling Efficient Attack Investigation from System Monitoring Data
Application Memory Isolation on Ultra-Low-Power MCUs
Peeking Behind the Curtains of Serverless Platforms
Soteria: Automated IoT Safety and Security Analysis
Scaling Guest OS Critical Sections with eCS
KylinX: A Dynamic Library Operating System for Simplified and Efficient Cloud Virtualization
Virtualizing Energy Storage Management Using RAIBA
Cntr: Lightweight OS Containers
Throwhammer: Rowhammer Attacks over the Network and Defenses
Varys: Protecting SGX Enclaves from Practical Side-Channel Attacks
Kernel-Supported Cost-Effective Audit Logging for Causality Tracking
EPTI: Efficient Defence against Meltdown Attack for Unpatched VMs
Effectively Mitigating I/O Inactivity in vCPU Scheduling
Placement of Virtual Containers on NUMA systems: A Practical and Comprehensive Model
Getting to the Root of Concurrent Binary Search Tree Performance
TerseCades: Efficient Data Compression in Stream Processing
Troubleshooting Transiently-Recurring Errors in Production Systems with Blame-Proportional Logging
NanoLog: A Nanosecond Scale Logging System
Model Governance: Reducing the Anarchy of Production ML
Fine-grained consistency for geo-replicated systems
Log-Free Concurrent Data Structures
Stable and Consistent Membership at Scale with Rapid
On Smart Query Routing: For Distributed Graph Querying with Decoupled Storage
Locality-Aware Software Throttling for Sparse Matrix Operation on GPUs
Accelerating PageRank using Partition-Centric Processing
CGraph: A Correlations-aware Approach for Efficient Concurrent Iterative Graph Processing
Don’t share, Don’t lock: Large-scale Software Connection Tracking with Krononat
Accurate Timeout Detection Despite Arbitrary Processing Delays
Improving Service Availability of Cloud Systems by Predicting Disk Error
RAFI: Risk-Aware Failure Identification to Improve the RAS in Erasure-coded Data Centers
Siphon: Expediting Inter-Datacenter Coflows in Wide-Area Data Analytics
PerfIso: Performance Isolation for Commercial Latency-Sensitive Services
On the diversity of cluster workloads and its impact on research results
Spindle: Informed Memory Access Monitoring
Touchstone: Generating Enormous Query-Aware Test Databases
DSAC: Effective Static Analysis of Sleep-in-Atomic-Context Bugs in Kernel Modules
Coccinelle: 10 Years of Automated Evolution in the Linux Kernel
Albis: High-Performance File Format for Big Data Systems
Litz: Elastic Framework for High-Performance Distributed Machine Learning
Putting the “Micro” Back in Microservice
Fast and Concurrent RDF Queries using RDMA-assisted GPU Graph Exploration
MDev-NVMe: A NVMe Storage Virtualization Solution with Mediated Pass-Through
Geriatrix: Aging what you see and what you don’t see. A file system aging approach for modern storage systems
AutoSSD: an Autonomic SSD Architecture
Can’t We All Get Along? Redesigning Protection Storage for Modern Workloads
STMS: Improving MPTCP Throughput Under Heterogeneous Networks
Pantheon: the training ground for Internet congestion-control research
ClickNF: a Modular Stack for Custom Network Functions
Selecta: Heterogeneous Cloud Storage Configuration for Data Analytics
Remote regions: a simple abstraction for remote memory
Understanding Ephemeral Storage for Serverless Analytics
Solar: Towards a Shared-Everything Database on Distributed Log-Structured Storage
Toward Coordination-free and Reconfigurable Mixed Concurrency Control
Scaling Hardware Accelerated Network Monitoring to Concurrent and Dynamic Queries With *Flow
Applying Hardware Transactional Memory for Concurrency-Bug Failure Recovery in Production Runs
Tailwind: Fast and Atomic RDMA-based Replication
On Fault Tolerance, Locality, and Optimality in Locally Repairable Codes
TxFS: Leveraging File-System Crash Consistency to Provide ACID Transactions
Towards Better Understanding of Black-box Auto-Tuning: A Comparative Analysis for Storage Systems
HeavyKeeper: An Accurate Algorithm for Finding Top-k Elephant Flows
SAND: Towards High-Performance Serverless Computing
Cavs: An Efficient Runtime System for Dynamic Neural Networks
DeepCPU: Serving RNN-based Deep Learning Models 10x Faster
Metis: Robustly Tuning Tail Latencies of Cloud Systems
HashKV: Enabling Efficient Updates in KV Storage via Hashing
Closing the Performance Gap Between Volatile and Persistent Key-Value Stores Using Cross-Referencing Logs
Computer Systems Research in the Post-Virtualization Era
Lock-in-Pop: Securing Privileged Operating System Kernels by Keeping on the Beaten Path
Fast and Precise Retrieval of Forward and Back Porting Information for Linux Device Drivers
Optimizing the TLB Shootdown Algorithm with Page Access Tracking
Falcon: Scaling IO Performance in Multi-SSD Volumes
deTector: a Topology-aware Monitoring System for Data Center Networks
Pricing Intra-Datacenter Networks with Over-Committed Bandwidth Guarantee
Unobtrusive Deferred Update Stabilization for Efficient Geo-Replication
Don’t cry over spilled records: Memory elasticity of data-parallel applications and its application to cluster scheduling
Popularity Prediction of Facebook Videos for Higher Quality Streaming
Squeezing out All the Value of Loaded Data: An Out-of-core Graph Processing System with Reduced Disk I/O
Ending the Anomaly: Achieving Low Latency and Airtime Fairness in WiFi
Persona: A High-Performance Bioinformatics Framework
SPIN: Seamless Operating System Integration of Peer-to-Peer DMA Between SSDs and GPUs
Poseidon: An Efficient Communication Architecture for Distributed Deep Learning on GPU Clusters
Garaph: Efficient GPU-accelerated Graph Processing on a Single Machine with Balanced Replication
GPU Taint Tracking
Optimizing the Design and Implementation of the Linux ARM Hypervisor
Multi-Hypervisor Virtual Machines: Enabling an Ecosystem of Hypervisor-level Services
Preemptive, Low Latency Datacenter Scheduling via Lightweight Virtualization
The RCU-Reader Preemption Problem in VMs
Bunshin: Compositing Security Mechanisms through Diversification
Glamdring: Automatic Application Partitioning for Intel SGX
High-Resolution Side Channels for Untrusted Operating Systems
Understanding Security Implications of Using Containers in the Cloud
Memshare: a Dynamic Multi-tenant Key-value Cache
Replication-driven Live Reconfiguration for Fast Distributed Transaction Processing
HiKV: A Hybrid Index Key-Value Store for DRAM-NVM Memory Systems
TRIAD: Creating Synergies Between Memory, Disk and Log in Log Structured Key-Value Stores
Visualizing Performance with Flame Graphs
Performance Superpowers with Enhanced BPF
Engineering Record and Replay for Deployability
Proactive error prediction to improve storage system reliability
Towards Production-Run Heisenbugs Reproduction on Commercial Hardware
A DSL Approach to Reconcile Equivalent Divergent Program Executions
Titan: Fair Packet Scheduling for Commodity Multiqueue NICs
MopEye: Opportunistic Monitoring of Per-app Mobile Network Performance
Emu: Rapid Prototyping of Networking Services
Protego: Cloud-Scale Multitenant IPsec Gateway
Cache Modeling and Optimization using Miniature Simulations
Hyperbolic Caching: Flexible Caching for Web Applications
cHash: Detection of Redundant Compilations via AST Hashing
Execution Templates: Caching Control Plane Decisions for Strong Scaling of Data Analytics
Application Crash Consistency and Performance with CCFS
Push-Button Verification of File Systems via Crash Refinement
Early Detection of Configuration Errors to Reduce Failure Damage
Fast, Lean, and Accurate: Modeling Password Guessability Using Neural Networks
Giza: Erasure Coding Objects across Global Data Centers
SmartCuckoo: A Fast and Cost-Efficient Hashing Index Scheme for Cloud Storage Systems
Repair Pipelining for Erasure-Coded Storage
PARIX: Speculative Partial Writes in Erasure-Coded Systems
E-Team: Practical Energy Accounting for Multi-Core Systems
Scalable NUMA-aware Blocking Synchronization Primitives
StreamBox: Modern Stream Processing on a Multicore Machine
Everything you always wanted to know about multicore graph processing but were afraid to ask
PrivApprox: Privacy-Preserving Stream Analytics
Graphene-SGX: A Practical Library OS for Unmodified Applications on SGX
Mercury: Bandwidth-Effective Prevention of Rollback Attacks Against Community Repositories
CAB-Fuzz: Practical Concolic Testing Techniques for COTS Operating Systems
Log-Structured Non-Volatile Main Memory
SmartMD: A High Performance Deduplication Engine with Mixed Pages
Soft Updates Made Simple and Fast on Non-volatile Memory
Elastic Memory Management for Cloud Data Analytics
Improving File System Performance of Mobile Storage Systems Using a Decoupled Defragmenter
Octopus: an RDMA-enabled Distributed Persistent Memory File System
iJournaling: Fine-Grained Journaling for Improving the Latency of Fsync System Call
Scaling Distributed File Systems in Resource-Harvesting Datacenters
Computer Systems Research in the Post-Virtualization Era
Lock-in-Pop: Securing Privileged Operating System Kernels by Keeping on the Beaten Path
Fast and Precise Retrieval of Forward and Back Porting Information for Linux Device Drivers
Optimizing the TLB Shootdown Algorithm with Page Access Tracking
Falcon: Scaling IO Performance in Multi-SSD Volumes
deTector: a Topology-aware Monitoring System for Data Center Networks
Pricing Intra-Datacenter Networks with Over-Committed Bandwidth Guarantee
Unobtrusive Deferred Update Stabilization for Efficient Geo-Replication
Don’t cry over spilled records: Memory elasticity of data-parallel applications and its application to cluster scheduling
Popularity Prediction of Facebook Videos for Higher Quality Streaming
Squeezing out All the Value of Loaded Data: An Out-of-core Graph Processing System with Reduced Disk I/O
Ending the Anomaly: Achieving Low Latency and Airtime Fairness in WiFi
Persona: A High-Performance Bioinformatics Framework
SPIN: Seamless Operating System Integration of Peer-to-Peer DMA Between SSDs and GPUs
Poseidon: An Efficient Communication Architecture for Distributed Deep Learning on GPU Clusters
Garaph: Efficient GPU-accelerated Graph Processing on a Single Machine with Balanced Replication
GPU Taint Tracking
Optimizing the Design and Implementation of the Linux ARM Hypervisor
Multi-Hypervisor Virtual Machines: Enabling an Ecosystem of Hypervisor-level Services
Preemptive, Low Latency Datacenter Scheduling via Lightweight Virtualization
The RCU-Reader Preemption Problem in VMs
Bunshin: Compositing Security Mechanisms through Diversification
Glamdring: Automatic Application Partitioning for Intel SGX
High-Resolution Side Channels for Untrusted Operating Systems
Understanding Security Implications of Using Containers in the Cloud
Memshare: a Dynamic Multi-tenant Key-value Cache
Replication-driven Live Reconfiguration for Fast Distributed Transaction Processing
TRIAD: Creating Synergies Between Memory, Disk and Log in Log Structured Key-Value Stores
Performance Superpowers with Enhanced BPF
Engineering Record and Replay for Deployability
Proactive error prediction to improve storage system reliability
Towards Production-Run Heisenbugs Reproduction on Commercial Hardware
A DSL Approach to Reconcile Equivalent Divergent Program Executions
Titan: Fair Packet Scheduling for Commodity Multiqueue NICs
MopEye: Opportunistic Monitoring of Per-app Mobile Network Performance
Emu: Rapid Prototyping of Networking Services
Protego: Cloud-Scale Multitenant IPsec Gateway
Cache Modeling and Optimization using Miniature Simulations
Hyperbolic Caching: Flexible Caching for Web Applications
Execution Templates: Caching Control Plane Decisions for Strong Scaling of Data Analytics
cHash: Detection of Redundant Compilations via AST Hashing
Application Crash Consistency and Performance with CCFS
Push-Button Verification of File Systems via Crash Refinement
Early Detection of Configuration Errors to Reduce Failure Damage
Fast, Lean, and Accurate: Modeling Password Guessability Using Neural Networks
Giza: Erasure Coding Objects across Global Data Centers
SmartCuckoo: A Fast and Cost-Efficient Hashing Index Scheme for Cloud Storage Systems
Repair Pipelining for Erasure-Coded Storage
PARIX: Speculative Partial Writes in Erasure-Coded Systems
E-Team: Practical Energy Accounting for Multi-Core Systems
Scalable NUMA-aware Blocking Synchronization Primitives
StreamBox: Modern Stream Processing on a Multicore Machine
Everything you always wanted to know about multicore graph processing but were afraid to ask
Graphene-SGX: A Practical Library OS for Unmodified Applications on SGX
PrivApprox: Privacy-Preserving Stream Analytics
Mercury: Bandwidth-Effective Prevention of Rollback Attacks Against Community Repositories
CAB-Fuzz: Practical Concolic Testing Techniques for COTS Operating Systems
Log-Structured Non-Volatile Main Memory
Soft Updates Made Simple and Fast on Non-volatile Memory
SmartMD: A High Performance Deduplication Engine with Mixed Pages
Elastic Memory Management for Cloud Data Analytics
Improving File System Performance of Mobile Storage Systems Using a Decoupled Defragmenter
Octopus: an RDMA-enabled Distributed Persistent Memory File System
iJournaling: Fine-Grained Journaling for Improving the Latency of Fsync System Call
Scaling Distributed File Systems in Resource-Harvesting Datacenters
FLICK: Developing and Running Application-Specific Network Services
SoftFlow: A Middlebox Architecture for Open vSwitch
Fast and Cautious: Leveraging Multi-path Diversity for Transport Loss Recovery in Data Centers
StackMap: Low-Latency Networking with the OS Stack and Dedicated NICs
SLIK: Scalable Low-Latency Indexes for a Key-Value Store
Understanding Manycore Scalability of File Systems
ParaFS: A Log-Structured File System to Exploit the Internal Parallelism of Flash Devices
FastCDC: A Fast and Efficient Content-Defined Chunking Approach for Data Deduplication
Secure and Efficient Application Monitoring and Replication
Blockstack: A Global Naming and Storage System Secured by Blockchains
Satellite: Joint Analysis of CDNs and Network-Level Interference
Subversive-C: Abusing and Protecting Dynamic Message Dispatch
Opportunities and Challenges in Adopting Microservice Architectures for Enterprise Workloads
Jenkins Job Builder – What? Why? How?
Bring Your Own Dilemma: OEM Laptops and Windows 10 Issues
In-place Resumable Partial Decompression Technique and Its Application to A Real Deduplicated Storage System
Unsafe Time Handling in Smartphones
Energy Discounted Computing on Multicore Smartphones
Beam: Ending Monolithic Applications for Connected Devices
Caching Doesn’t Improve Mobile Web Performance (Much)
The Next Generation of Apache Hadoop: Open Problems in Distributed Storage and Resource Management
Optimizing Every Operation in a Write-optimized File System
Pivot Tracing: Dynamic Causal Monitoring for Distributed Systems
Environmental Conditions and Disk Reliability in Free-cooled Datacenters
Horton Tables: Fast Hash Tables for In-Memory Data-Intensive Computing
Ginseng: Market-Driven LLC Allocation
Elfen Scheduling: Fine-Grain Principled Borrowing from Latency-Critical Workloads Using Simultaneous Multithreading
Coherence Stalls or Latency Tolerance: Informed CPU Scheduling for Socket and Core Sharing
Unlocking Energy
Greening the Video Transcoding Service with Low-Cost Hardware Transcoders
MEANTIME: Achieving Both Minimal Energy and Timeliness with Approximate Computing
Using Crash Hoare Logic for Certifying the FSCQ File System
COZ: Finding Code that Counts with Causal Profiling
All Your Biases Belong to Us: Breaking RC4 in WPA-TKIP and TLS
Under-Constrained Symbolic Execution: Correctness Checking for Real Code
Hardware-Assisted On-Demand Hypervisor Activation for Efficient Security Critical Code Execution on Mobile Devices
gScale: Scaling up GPU Virtualization with Dynamic Sharing of Graphics Memory Space
A General Persistent Code Caching Framework for Dynamic Binary Translation (DBT)
Passive Wi-Fi: Bringing Low Power to Wi-Fi Transmissions
An Industrial-Scale Software Defined Internet Exchange Point
PhyCloak: Obfuscating Sensing from Communication Signals
Hyperprobe: Towards Virtual Machine Extrospection
Spartan: A Distributed Array Framework with Smart Tiling
Experience with Rules-Based Programming for Distributed, Concurrent, Fault-Tolerant Code
Tiered Replication: A Cost-effective Alternative to Full Cluster Geo-replication
Callisto-RTS: Fine-Grain Parallel Loops
LAMA: Optimized Locality-aware Memory Allocation for Key-value Cache
LSM-trie: An LSM-tree-based Ultra-Large Key-Value Store for Small Data Items
MetaSync: File Synchronization Across Multiple Untrusted Storage Services
Pyro: A Spatial-Temporal Big-Data Storage System
CDStore: Toward Reliable, Secure, and Cost-Efficient Cloud Storage via Convergent Dispersal
Surviving Peripheral Failures in Embedded Systems
Log2: A Cost-Aware Logging Mechanism for Performance Diagnosis
Identifying Trends in Enterprise Data Protection Systems
Systematically Exploring the Behavior of Control Programs
Fence: Protecting Device Availability With Uniform Resource Control
Request-Oriented Durable Write Caching for Application Performance
NVMKV: A Scalable, Lightweight, FTL-aware Key-Value Store
Lightweight Application-Level Crash Consistency on Transactional Flash Storage
WALDIO: Eliminating the Filesystem Journaling in Resolving the Journaling of Journal Anomaly
SpanFS: A Scalable File System on Fast Storage Devices
Shoal: Smart Allocation and Replication of Memory For Parallel Programs
Thread and Memory Placement on NUMA Systems: Asymmetry Matters
Latency-Tolerant Software Distributed Shared Memory
NightWatch: Integrating Lightweight and Transparent Cache Pollution Control into Dynamic Memory Allocation Systems
Secure Deduplication of General Computations
Lamassu: Storage-Efficient Host-Side Encryption
SecPod: a Framework for Virtualization-based Security Systems
Between Mutual Trust and Mutual Distrust: Practical Fine-grained Privilege Separation in Multithreaded Applications
GridGraph: Large-Scale Graph Processing on a Single Machine Using 2-Level Hierarchical Partitioning
GraphQ: Graph Query Processing with Abstraction Refinement—Scalable and Programmable Analytics over Very Large Graphs on a Single PC
Accurate Latency-based Congestion Feedback for Datacenters
Mahimahi: Accurate Record-and-Replay for HTTP
Slipstream: Automatic Interprocess Communication Optimization
FloSIS: A Highly Scalable Network Flow Capture System for Fast Retrieval and Storage Efficiency
Bolt: Faster Reconfiguration in Operating Systems
Boosting GPU Virtualization Performance with Hybrid Shadow Page Tables
Data Sharing or Resource Contention: Toward Performance Transparency on Multicore Systems
Utilizing the IOMMU Scalably
Selling Stuff That’s Free: the Commercial Side of Free Software
Simba: Building Data-Centric Applications for Mobile Devices
A New Paradigm for Power Management
Faster Booting in Consumer Electronics
Arrakis: The Operating System is the Control Plane
Shielding Applications from an Untrusted Cloud with Haven
IX: A Protected Dataplane Operating System for High Throughput and Low Latency
Privacy in Pharmacogenetics: An End-to-End Case Study of Personalized Warfarin Dosing
Skylight—A Window on Shingled Disk Operation
Scalability and Load in Online Games
Erasure Code Foundations
Experiences with Scaling Blockchain-based Data Stores
Its Not Your Father’s Scale-out Storage Architecture!
Hypervisor-based Memory Introspection at the Next Level: User-Mode Memory Introspection and Protection of Live VMs
Terminal.com: Full System Linux Containers with Bare-metal Speed
In a World of Ephemeral Containers, How Do We Keep Track of Things?
Mambo: Running Analytics on Enterprise Storage
A Reference Architecture for Securing Big Data Infrastructures
Power Your Big Data Analytics With Pivotal Greenplum Database
The Design and Implementation of Open vSwitch
Designing Distributed Systems Using Approximate Synchrony in Data Center Networks
Queues Don’t Matter When You Can JUMP Them!
Realtime High-Speed Network Traffic Monitoring Using ntopng
Experience with B4: Google’s Private SDN Backbone
Bistro: Scheduling Data-Parallel Jobs Against Live Production Systems
Rubik: Unlocking the Power of Locality and End-point Flexibility in Cloud Scale Load Balancing
Mercury: Hybrid Centralized and Distributed Scheduling in Large Shared Clusters
Hawk: Hybrid Datacenter Scheduling
Selectively Taming Background Android Apps to Improve Battery Lifetime
U-root: A Go-based, Firmware Embeddable Root File System with On-demand Compilation
LPD: Low Power Display Mechanism for Mobile and Wearable Devices
Memory-Centric Data Storage for Mobile Systems
WearDrive: Fast and Energy-Efficient Storage for Wearables
ShuffleWatcher: Shuffle-aware Scheduling in Multi-tenant MapReduce Clusters
Violet: A Storage Stack for IOPS/Capacity Bifurcated Storage Environments
ELF: Efficient Lightweight Fast Stream Processing at Scale
Exploiting Bounded Staleness to Speed Up Big Data Analytics
Making State Explicit for Imperative Big Data Processing
OSv—Optimizing the Operating System for Virtual Machines
Gleaner: Mitigating the Blocked-Waiter Wakeup Problem for Virtualized Multicore Applications
HYPERSHELL: A Practical Hypervisor Layer Guest OS Shell for Automated In-VM Management
XvMotion: Unified Virtual Machine Migration over Long Distance
GPUvm: Why Not Virtualizing GPUs at the Hypervisor?
A Full GPU Virtualization Solution with Mediated Pass-Through
vCacheShare: Automated Server Flash Cache Space Management in a Virtualization Environment
Missive: Fast Application Launch From an Untrusted Buffer Cache
A Modular and Efficient Past State System for Berkeley DB
SCFS: A Shared Cloud-backed File System
Accelerating Restore and Garbage Collection in Deduplication-based Backup Systems via Exploiting Historical Information
The TURBO Diaries: Application-controlled Frequency Scaling Explained
Implementing a Leading Loads Performance Predictor on Commodity Processors
HaPPy: Hyperthread-aware Power Profiling Dynamically
Scalable Read-mostly Synchronization Using Passive Reader-Writer Locks
Large Pages May Be Harmful on NUMA Systems
Efficient Tracing of Cold Code via Bias-Free Sampling
Gestalt: Fast, Unified Fault Localization for Networked Systems
Insight: In-situ Online Service Failure Path Inference in Production Computing Infrastructures
Automating the Choice of Consistency Levels in Replicated Systems
Sirius: Distributing and Coordinating Application Reference Data
In Search of an Understandable Consensus Algorithm
GASPP: A GPU-Accelerated Stateful Packet Processing Framework
Panopticon: Reaping the Benefits of Incremental SDN Deployment in Enterprise Networks
Pythia: Diagnosing Performance Problems in Wide Area Providers
BISmark: A Testbed for Deploying Measurements and Applications in Broadband Access Networks
Programmatic Orchestration of WiFi Networks
HACK: Hierarchical ACKs for Efficient Wireless Medium Utilization
Application-Defined Decentralized Access Control
MiniBox: A Two-Way Sandbox for x86 Native Code
Static Analysis of Variability in System Software: The 90,000 #ifdefs Issue
Yat: A Validation Framework for Persistent Memory Software
Medusa: Managing Concurrency and Communication in Embedded Systems
Reliable Writeback for Client-side Flash Caches
Flash on Rails: Consistent Flash Performance through Redundancy
I/O Speculation for the Microsecond Era
OS I/O Path Optimizations for Flash Solid-state Drives
FlexECC: Partially Relaxing ECC of MLC SSD for Better Cache Performance
Nitro: A Capacity-Optimized SSD Cache for Primary Storage
Naiad: A Timely Dataflow System
mTCP: a Highly Scalable User-level TCP Stack for Multicore Systems
The Scalable Commutativity Rule: Designing Scalable Software for Multicore Processors
Securing Computer Hardware Using 3D Integrated Circuit (IC) Technology and Split Manufacturing for Obfuscation
Control Flow Integrity for COTS Binaries
Back to the Future: Fault-tolerant Live Update with Time-traveling State Transfer
dsync: Efficient Block-wise Synchronization of Multi-Gigabyte Binary Data
Self-Tuning Intel Transactional Synchronization Extensions
Optimizing VM Checkpointing for Restore Performance in VMware ESXi
Hyper-Switch: A Scalable Software Virtual Switching Architecture
MiG: Efficient Migration of Desktop VMs Using Semantic Compression
Copysets: Reducing the Frequency of Data Loss in Cloud Storage
TAO: Facebook’s Distributed Data Store for the Social Graph
PIKACHU: How to Rebalance Load in Optimizing MapReduce On Heterogeneous Clusters
FlashFQ: A Fair Queueing I/O Scheduler for Flash-Based SSDs
The Harey Tortoise: Managing Heterogeneous Write Performance in SSDs
Janus: Optimal Flash Provisioning for Cloud Storage Workloads
Using One-Sided RDMA Reads to Build a Fast, CPU-Efficient Key-Value Store
Lightweight Memory Tracing
Flash Caching on the Storage Client
Practical and Effective Sandboxing for Non-root Users
TABLEFS: Enhancing Metadata Efficiency in the Local File System
Characterization of Incremental Data Changes for Efficient Data Protection
On the Efficiency of Durable State Machine Replication
Estimating Duplication by Content-based Sampling
MutantX-S: Scalable Malware Clustering Based on Static Features
Redundant State Detection for Dynamic Symbolic Execution
packetdrill: Scriptable Network Stack Testing, from Sockets to Packets
DeepDive: Transparently Identifying and Managing Performance Interference in Virtualized Environments
Efficient and Scalable Paravirtual I/O System
vTurbo: Accelerating Virtual Machine I/O Processing Using Designated Turbo-Sliced Core
When Slower Is Faster: On Heterogeneous Multicores for Reliable Systems
IAMEM: Interaction-Aware Memory Energy Management
XLH: More Effective Memory Deduplication Scanners Through Cross-layer Hints
Enabling OS Research by Inferring Interactions in the Black-Box GPU Stack
Mantis: Automatic Performance Prediction for Smartphone Applications
I/O Stack Optimization for Smartphones
How to Run POSIX Apps in a Minimal Picoprocess
Network Interface Design for Low Latency Request-Response Protocols
DEFINED: Deterministic Execution for Interactive Control-Plane Debugging
Improving Server Application Performance via Pure TCP ACK Receive Optimization
Demand Based Hierarchical QoS Using Storage Resource Pools
Erasure Coding in Windows Azure Storage
Managing Large Graphs on Multi-Cores with Graph Awareness
MemProf: A Memory Profiler for NUMA Multicore Systems
Remote Core Locking: Migrating Critical-Section Execution to Improve the Performance of Multithreaded Applications
Building a Power-Proportional Software Router
netmap: A Novel Framework for Fast Packet I/O
Toward Efficient Querying of Compressed Network Payloads
Body Armor for Binaries: Preventing Buffer Overflows Without Recompilation
Abstractions for Usable Information Flow Control in Aeolus
Treehouse: Javascript Sandboxes to Help Web Developers Help Themselves
Cloud Terminal: Secure Access to Sensitive Applications from Untrusted Systems
Mosh: An Interactive Remote Shell for Mobile Clients
TROPIC: Transactional Resource Orchestration Platform in the Cloud
Trickle: Rate Limiting YouTube Video Streaming
Tolerating Overload Attacks Against Packet Capturing Systems
Enforcing Murphy’s Law for Advance Identification of Run-time Failures
A Scalable Server for 3D Metaverses
High Performance Vehicular Connectivity with Opportunistic Erasure Coding
Server-assisted Latency Management for Wide-area Distributed Systems
Generating Realistic Datasets for Deduplication Analysis
An Empirical Study of Memory Sharing in Virtual Machines
Primary Data Deduplication—Large Scale Study and System Design
Design and Implementation of an Embedded Python Run-Time System
AddressSanitizer: A Fast Address Sanity Checker
Software Persistent Memory
Rivet: Browser-agnostic Remote Debugging for Web Applications
Wimpy Nodes with 10GbE: Leveraging One-Sided Operations in Soft-RDMA to Boost Memcached
Revisiting Software Zero-Copy for Web-caching Applications with Twin Memory Allocation
Seagull: Intelligent Cloud Bursting for Enterprise Applications
The Forgotten ‘Uncore’: On the Energy-Efficiency of Heterogeneous Cores
Software Techniques for Avoiding Hardware Virtualization Exits
AppScope: Application Energy Metering Framework for Android Smartphone Using Kernel Activity Monitoring
Gdev: First-Class GPU Resource Management in the Operating System
Gnothi: Separating Data and Metadata for Efficient and Available Storage Replication
Dynamic Reconfiguration of Primary/Backup Clusters
Surviving Congestion in Geo-Distributed Storage Systems
Practical Hardening of Crash-Tolerant Systems
A Case for NUMA-aware Contention Management on Multicore Systems
TimeGraph: GPU Scheduling for Real-Time Multi-Tasking Environments
Pegasus: Coordinated Scheduling for Virtualized Accelerator-based Systems
vIC: Interrupt Coalescing for Virtual Machine Storage Device IO
Power Budgeting for Virtualized Data Centers
vIOMMU: Efficient IOMMU Emulation
HiTune: Dataflow-Based Performance Analysis for Big Data Cloud
Taming the Flying Cable Monster: A Topology Design and Optimization Framework for Data-Center Networks
In-situ MapReduce for Log Processing
Exception-Less System Calls for Event-Driven Servers
Resizable, Scalable, Concurrent Hash Tables via Relativistic Programming
Evaluating the Effectiveness of Model-Based Power Characterization
The Design and Evolution of Live Storage Migration in VMware ESX
Online Migration for Geo-distributed Storage Systems
Slow Down or Sleep, That Is the Question
Low Cost Working Set Size Tracking
FVD: A High-Performance Virtual Machine Image Format for Cloud
Okeanos: Wasteless Journaling for Fast and Reliable Multistream Storage
Toward Online Testing of Federated and Heterogeneous Distributed Systems
CDE: Using System Call Interposition to Automatically Create Portable Software Packages
Vsys: A Programmable sudo
Internet-scale Visualization and Detection of Performance Events
Polygraph: System for Dynamic Reduction of False Alerts in Large-Scale IT Service Delivery Environments
SiLo: A Similarity-Locality based Near-Exact Deduplication Scheme with Low RAM Overhead and High Throughput
G2: A Graph Processing System for Diagnosing Distributed Systems
Context-based Online Configuration-Error Detection
OFRewind: Enabling Record and Replay Troubleshooting for Networks
ORDER: Object centRic DEterministic Replay for Java
Enabling Security in Cloud Storage SLAs with CloudProof
jVPFS: Adding Robustness to a Secure Stacked File System with Untrusted Local Storage Components
Semantics of Caching with SPOCA: A Stateless, Proportional, Optimally-Consistent Addressing Algorithm
TidyFS: A Simple and Small Distributed File System
Eyo: Device-Transparent Personal Storage
Autonomous Storage Management for Personal Devices with PodBase
DEFCON: High-Performance Event Processing with Information Security
Wide-Area Route Control for Distributed Services
LiteGreen: Saving Energy in Networked Desktops Using Virtualization
Stout: An Adaptive Interface to Scalable Cloud Storage
IsoStack—Highly Efficient Network Processing on Dedicated Cores
A Realistic Evaluation of Memory Hardware Errors and Software System Susceptibility
The Utility Coprocessor: Massively Parallel Computation from the Coffee Shop
Apiary: Easy-to-Use Desktop Application Fault Containment on Commodity Operating Systems
Tolerating Malicious Device Drivers in Linux
ZooKeeper: Wait-free Coordination for Internet-scale Systems
FlashVM: Virtual Memory Management on Flash
A Transparently-Scalable Metadata Service for the Ursa Minor Storage System
Dyson: An Architecture for Extensible Wireless LANs
ChunkStash: Speeding Up Inline Storage Deduplication Using Flash Memory
Sleepless in Seattle No Longer
vNUMA: A Virtual Shared-Memory Multiprocessor
ShadowNet: A Platform for Rapid and Safe Network Evolution
Design and Implementation of TCP Data Probes for Reliable and Metric-Rich Network Path Monitoring
StrobeLight: Lightweight Availability Mapping and Anomaly Detection
Hashing Round-down Prefixes for Rapid Packet Classification
Tolerating File-System Mistakes with EnvyFS
Decentralized Deduplication in SAN Cluster File Systems
FlexFS: A Flexible Flash File System for MLC NAND Flash Memory
Layering in Provenance Systems
Census: Location-Aware Membership Management for Large-Scale Distributed Systems
Veracity: Practical Secure Network Coordinates via Vote-based Agreements
Rump File Systems: Kernel Code Reborn
Decaf: Moving Device Drivers to a Modern Language
CiAO: An Aspect-Oriented Operating-System Family for Resource-Constrained Embedded Systems
JustRunIt: Experiment-Based Management of Virtualized Data Centers
Automatically Generating Predicates and Solutions for Configuration Troubleshooting
vPath: Precise Discovery of Request Processing Paths from Black-Box Observations of Thread and Network Activities
The Restoration of Early UNIX Artifacts
Block Management in Solid-State Devices
Linux Kernel Developer Responses to Static Analysis Bug Reports
Hardware Execution Throttling for Multi-core Resource Management
Reducing Seek Overhead with Application-Directed Prefetching
Fido: Fast Inter-Virtual-Machine Communication for Enterprise Appliances
STOW: A Spatially and Temporally Optimized Write Caching Algorithm
Server Workload Analysis for Power Minimization using Consolidation
RCB: A Simple and Practical Framework for Real-time Collaborative Browsing
Immediate Multi-Threaded Dynamic Software Updates Using Stack Reconstruction
Fast, Inexpensive Content-Addressed Storage in Foundation
Adaptive File Transfers for Diverse Environments
Web and Internet Services
Remote Profiling of Resource Constraints of Web Servers Using Mini-Flash Crowds
Workloads and Benchmarks
Evaluating Distributed Systems: Does Background Traffic Matter?
Cutting Corners: Workbench Automation for Server Benchmarking
A Linux Implementation Validation of Track-Aligned Extents and Track-Aligned RAIDs
Automatic Optimization of Parallel Dataflow Programs
A TCP-layer Name Service for TCP Ports
Using Causality to Diagnose Configuration Bugs
Diverse Replication for Single-Machine Byzantine-Fault Tolerance
LeakSurvivor: Towards Safely Tolerating Memory Leaks for Garbage-Collected Languages
Perspectives: Improving SSH-style Host Authentication with Multi-Path Probing
Spectator: Detection and Containment of JavaScript Worms
Memory and Buffer Management
Prefetching with Adaptive Cache Culling for Striped Disk Arrays
Context-Aware Prefetching at the Storage Server
Wide-Scale Data Stream Management
Experiences with Client-based Speculative Remote Display
Energy Management for Hypervisor-Based Virtual Machines
Virtual Machine Memory Access Tracing with Hypervisor Exclusive Cache
Hyperion: High Volume Stream Archival for Retrospective Querying
Load Shedding in Network Monitoring Applications
Configuration Management at Massive Scale: System Design and Experience
Events Can Make Sense
MapJAX: Data Structure Abstractions for Asynchronous Web Applications
Sprockets: Safe Extensions for Distributed File Systems
SafeStore: A Durable and Practical Storage System
POTSHARDS: Secure Long-Term Storage Without Encryption
Dandelion: Cooperative Content Distribution with Robust Incentives
Using Provenance to Aid in Personal File Search
Supporting Practical Content-Addressable Caching with CZIP Compression
Short Paper: Implementation and Performance Evaluation of Fuzzy File Block Matching
From Trusted to Secure: Building and Executing Applications That Enforce System Security
From STEM to SEAD: Speculative Execution for Automated Defense
Dynamic Spyware Analysis
Evaluating Block-level Optimization Through the IO Path
DiskSeen: Exploiting Disk Layout and Access History to Enhance I/O Prefetch
Short Paper: A Memory Soft Error Measurement on Production Systems
Addressing Email Loss with SureMail: Measurement, Design, and Evaluation
Wresting Control from BGP: Scalable Fine-Grained Route Control
A Comparison of Structured and Unstructured P2P Approaches to Heterogeneous Random Peer Selection
Transparent Checkpoint-Restart of Multiple Processes on Commodity Operating Systems
Reboots Are for Hardware: Challenges and Solutions to Updating an Operating System on the Fly
Short Paper: Exploring Recovery from Operating System Lockups
Short Paper: Virtually Shared Displays and User Input Devices
Antfarm: Tracking Processes in a Virtual Machine Environment
Optimizing Network Virtualization in Xen
Provenance-Aware Storage Systems
Thresher: An Efficient Storage Manager for Copy-on-write Snapshots
Design Tradeoffs in Applying Content Addressable Storage to Enterprise-scale Systems Based on Virtual Machines
Compare-by-Hash: A Reasoned Analysis
Disk Drive Level Workload Characterization
Towards a Resilient Operating System for Wireless Sensor Networks
Transparent Contribution of Memory
Implementation and Evaluation of Moderate Parallelism in the BIND9 DNS Server
Flux: A Language for Programming High-Performance Servers
Understanding and Addressing Blocking-Induced Network Server Latency
Reval: A Tool for Real-time Evaluation of DDoS Mitigation Strategies
LADS: Large-scale Automated DDoS Detection System
Bump in the Ether: A Framework for Securing Sensitive User Input
Sharing Networked Resources with Brokered Leases
Understanding and Validating Database System Administration
SMART: An Integrated Multi-Action Advisor for Storage Systems
sMonitor: A Non-Intrusive Client-Perceived End-to-End Performance Monitor of Secured Internet Services
Privacy Analysis for Data Sharing in *nix Systems
Securing Web Service by Automatic Robot Detection
Cutting through the Confusion: A Measurement Study of Homograph Attacks
Stealth Probing: Efficient Data-Plane Security for IP Routing
Service Placement in a Shared Wide-Area Platform
Replay Debugging for Distributed Applications
Loose Synchronization for Large-Scale Networked Systems
System- and Application-level Support for Runtime Hardware Reconfiguration on SoC Platforms
Resilient Connections for SSH and TLS
Reclaiming Network-wide Visibility Using Ubiquitous Endsystem Monitors
Integrated Scientific Workflow Management for the Emulab Network Testbed
How DNS Misnaming Distorts Internet Topology Mapping
Efficient Query Subscription Processing for Prospective Search Engines
IP Only Server
Structure and Performance of the Direct Access File System (DAFS)
Conquest: Better Performance Through a Disk/Persistent-RAM Hybrid File System
Exploiting Gray-Box Knowledge of Buffer-Cache Management
The JX Operating System
Design Evolution of the EROS Single-Level Store
Think: A Software Framework for Component-based Operating System Kernels
Linux NFS Client Write Performance
A Study of the Relative Costs of Network Security Protocols
Congestion Control in Linux TCP
The Future Is Coming: Where the X Window System Should Go
Ninja: A Framework for Network Services
Using Cohort Scheduling to Enhance Server Performance
Biglook: A Widget Library for the Scheme Programming Language
EtE: Passive End-to-End Internet Service Performance Monitoring
The Performance of Remote Display Mechanisms for Thin-Client Computing
Authorization and Charging in Public WLANs Using FreeBSD and 802.1x
My Cache or Yours? Making Storage More Exclusive
Gscope: A Visualization Tool for Time-Sensitive Software
Inferring Scheduling Behavior with Hourglass
A Decoupled Architecture for Application-Specific File Prefetching
Design and Performance of the OpenBSD Stateful Packet Filter (pf)
Simple and General Statistical Profiling with PCT
Engineering a Differencing and Compression Data Format
Enhancing NFS Cross-Administrative Domain Access
A Precise and Efficient Evaluation of the Proximity Between Web Clients and Their Local DNS Servers
Ningaui: A Linux Cluster for Business
CPCMS: A Configuration Management System Based on Cryptographic Names
X Meets Z: Verifying Correctness in the Presence of POSIX Threads
Providing Process Origin Information to Aid in Network Traceback
Cyclone: A Safe Dialect of C
Cooperative Task Management Without Manual Stack Management
Filesystem Performance and Scalability in Linux 2.4.17
Improving Wait-Free Algorithms for Interprocess Communication in Embedded Real-Time Systems
Robust Positioning Algorithms for Distributed Ad-Hoc Wireless Sensor Networks
Overhauling Amd for the ’00s: A Case Study of GNU Autotools
Speeding Up the Kernel Scheduler by Reducing Cache Misses
Simple Memory Protection for Embedded Operating System Kernels
Characterizing and Analyzing Alert and Browse Services of Mobile Clients
Making the Internet Mobile: Lessons from the Wireless Application Protocol (WAP)
User Space
Security Aspects of Napster and Gnutella
AppStreamer: Reducing Storage Requirements of Mobile Games through Predictive Streaming
Occlum: Secure and Efficient Multitasking Inside a Single Enclave of Intel SGX
SPARTA: A Divide and Conquer Approach to Address Translation for Accelerators
A New Fairness Model based on User’s Objective for Multi-user Multi-processor Online Scheduling
On Schedulability Analysis of EDF Scheduling by Considering Suspension as Blocking
Online Scheduling with Makespan Minimization: State of the Art Results, Research Challenges and Open Problems
Tuneful: An Online Significance-Aware Configuration Tuner for Big Data Analytics
A Simple and Efficient Binary Byzantine Consensus Algorithm using Cryptography and Partial Synchrony
Fine-grained Analysis on Fast Implementations of Multi-writer Atomic Registers
Enabling Highly-Scalable Remote Memory Access Programming with MPI-3 One Sided
Properties of the Tangle for Uniform Random and Random Walk Tip Selection
Properties of the Tangle for Uniform Random and Random Walk Tip Selection
Asynchronous Consensus Algorithm
Anchoring the value of Cryptocurrency
Simple and Fast Distributed Computation of Betweenness Centrality
Accelerating supply chains with Ant Colony Optimization across range of hardware solutions
An authentication protocol based on chaos and zero knowledge proof
Adaptive Large Neighborhood Search for Circle Bin Packing Problem
Lattice QCD on a novel vector architecture
Self Organization Agent Oriented Dynamic Resource Allocation on Open Federated Clouds Environment
Serverless Straggler Mitigation using Local Error-Correcting Codes
Transparently Capturing Request Execution Path for Anomaly Detection
A Simple Model for Portable and Fast Prediction of Execution Time and Power Consumption of GPU Kernels
OpenMP Parallelization of Dynamic Programming and Greedy Algorithms
Distributed Vehicular Computing at the Dawn of 5G: a Survey
BAASH: Enabling Blockchain-as-a-Service on High-Performance Computing Systems
The Parallelism Motifs of Genomic Data Analysis
75,000,000,000 Streaming Inserts/Second Using Hierarchical Hypersparse GraphBLAS Matrices
CycLedger: A Scalable and Secure Parallel Protocol for Distributed Ledger via Sharding
Combining Federated and Active Learning for Communication-efficient Distributed Failure Prediction in Aeronautics
Finding temporal patterns using algebraic fingerprints
High-Quality Hierarchical Process Mapping
Segment blockchain: A size reduced storage mechanism for blockchain
BlockHouse: Blockchain-based Distributed Storehouse System
Consistency of Proof-of-Stake Blockchains with Concurrent Honest Slot Leaders
Dynamic Byzantine Reliable Broadcast [Technical Report]
FRaZ: A Generic High-Fidelity Fixed-Ratio Lossy Compression Framework for Scientific Floating-point Data
GPU Tensor Cores for fast Arithmetic Reductions
Smart Data based Ensemble for Imbalanced Big Data Classification
Lazy object copy as a platform for population-based probabilistic programming
Incentive Analysis of Bitcoin-NG, Revisited
Entangled Polynomial Codes for Secure, Private, and Batch Distributed Matrix Multiplication: Breaking the ”Cubic” Barrier

#distributed-systems, #operating-systems