This class will explore a variety of topics in the rapidly evolving field of persistent memory, including hardware (memory and processor) foundations; formal correctness criteria (memory persistency, durable linearizability); persistent data structures; run-time systems for failure atomicity; dynamic memory allocation; and operating system support for failure recovery and for safe, user-level sharing.
Which algorithm, Paxos or Raft, is the best solution to distributed consensus?
A (brief) primer on debugging data races — both parallel and distributed.
In this talk, Ed will talk about TiDB and its columnar storage engine TiFlash from the perspective of engineering design, and explain how TiDB utilizes and extends Raft protocol to eliminate the impact of OLAP workload on OLTP, to achieve an industrial-grade HTAP database, and give relevant benchmarks and user cases.
We consider ups and downs of modern memory models for programming languages and requirements imposed on them by languages' pragmatics.
In this talk we will analyze how modern distributed storage systems behave in the presence of storage faults such as data corruption and read and write errors.
OakMap is part of the open source Oak library. It is a concurrent Key-Value Map that may keep all keys and values off-heap. OakMap decreases the memory requirements up to 3 times and experiments show that OakMap is often 2x faster than Java’s state-of-the-art concurrent skip-list. We will discuss OakMap technology and working with the off-heap memory: updating and concurrency.
In this talk, we will look at the architecture of YugabyteDB that enables it to support all PostgreSQL features along with distributed transactions, resilience, scalability, and geo-distribution of data.
The goal of this talk is to provide an overview of the role of distributed computing in machine learning, with an eye towards the intriguing trade-offs between synchronization and communication costs of distributed machine learning algorithms, on the one hand, and their convergence, on the other.
Project Loom is an attempt to introduce lightweight concurrency constructs to Java. Can it change the game of Java concurrency? Let's look into details.
In this talk we will see specific problems and solutions related to UI applications with heterogeneous threads. It will help you to avoid many pitfalls and make familiar with several approaches and tools that are invaluable for UI applications development.
In this talk Oleg will try to cover the advantages of stateful vs stateless microservices on the example of Odnoklassniki social network, discuss how statefulness affects reliability and accessibility of services and how it helps to build faster applications.
In this talk Maxim will give a brief overview of Erasure Coding schemes that we employ and discuss various real-world scenarios and lessons learned while operating these systems at scale.
In this talk, the audience will learn about the theoretical foundations behind failure detectors: underlying concepts, crucial properties, and differences in guarantees. We will look at applications of failure detection in several practical use cases and dive into the specifics of their implementation in some known distributed systems.
In this talk Alex will describe recent efforts to modernize Linux kernel locks, focusing on two concrete ideas.
The goal of this talk is to explain the Bitcoin algorithm from the distributed computing perspective.
This talk will present SegmentQueueSynchronizer — an abstraction for writing synchronization primitives with abortable operations simply and efficiently.
This talk will focus on one software modeling tool called TLA+, which has seen spectacular success in real-world projects. We will also demonstrate it on an example of a distributed system and closeout by discussing learning resources.
In this talk, we will discuss the memory reclamation problem, existing techniques, and how a recent wait-free WFE technique is constructed. We discuss what key challenges WFE solves so that it can be universally applied regardless of the data structure organization.
This talk describes how to improve on the following limitations of blockchain technologies and smart contract platforms: low throughput and high latency.
In this talk Martin goes beyond the introductory material on CRDTs, and discusses some of the hard-won lessons from years of research on making CRDTs work in practice.
We will present modern methods for formally specifying consistency models of distributed systems and reasoning about how their choice affects system correctness.
This class will explore a variety of topics in the rapidly evolving field of persistent memory, including hardware (memory and processor) foundations; formal correctness criteria (memory persistency, durable linearizability); persistent data structures; run-time systems for failure atomicity; dynamic memory allocation; and operating system support for failure recovery and for safe, user-level sharing.
This talk will present the Hodor project, which overcomes the single address space limitation by using the memory protection keys of recent Intel processors to implement a protected library mechanism.
This short course presents a brief introduction to concepts and tools from modern cryptography.
Idit will talk about distributed storage.
This lecture provides an overview of consistency, isolation, and the role of these concepts in modern storage systems.
In this talk, Jing Chen will introduce Algorand’s core technology, recent development and roadmap.
What do the properties of neural tissue have to do with the way we process data in convolutional neural networks (CNNs)? Perhaps more than we think. Nir Shavit will talk about that during this session.