1. June 2. Online

    • Watch recording
      Talk

      How ScyllaDB makes LSM-tree compaction state-of-art by leveraging RUM conjecture and controller theory

      LSM-tree storage engines are known for providing very fast write throughput, as they allow new data to be flushed into immutable files called Sorted String Table, a.k.a. SSTable. But there's no such thing as a free lunch. This append-only nature of the LSM tree generates read amplification over time, because a given key can be redundantly stored across multiple immutable files. That's the reason storage engines have to employ a background compaction process, to reduce both read and space amplification.

    • Watch recording
      Talk

      Solving Raft's practical problems in Tarantool. What, how and why

      Speakers began implementing Raft in Tarantool with somewhat inflated expectations:

      • expected the leader to be persistent, as long as it was alive and connected to most nodes;
      • expected that it would be impossible to get an "I am the leader" message from multiple nodes at the same time;
      • wanted a new leader to show up as quickly as possible if the leader failed;
        wanted to be able to go into "crash mode" where the cluster was writable even after more than half of the nodes had been lost.

      In fact, Raft promises none of these things. And to get it, it is necessary to implement some add-ons, about which we will talk.

    • Watch recording
      Talk

      Self-stabilizing Population Protocols

      Focusing on resources of memory and time, we will discuss how efficiently tasks can be solved when facing transient faults modeled by means of self-stabilization. The talk will give an overview of the related work and focus on several fundamental tasks like counting, naming, and leader election.

    • Watch recording
      Talk

      Exploring Traffic Jams in Your Data Flows

      In the real world, there's a phenomenon called a “phantom traffic jam” or a “traffic wave.” This is when there is a standing compression wave in automobile traffic, even though there is no accident, lane closure, or other incident that would cause the traffic jam. A similar phenomenon is possible in computer networking or storage I/O, where your data can slow down for no apparent reason. In this talk, Pavel is going to describe when and how this effect can arise and what can be done to discover it.

    • Watch recording
      Talk

      Making a desktop IDE distributed and collaborative

      In the year 2021, two particular features landed in the IntelliJ family of IDEs. Code With Me gives you the ability to invite and collaborate with others on the same project. Remote development is the feature that allows launching the IDE as a backend on a remote machine or a cloud that users can get access to instead of setting up and developing code locally. While the product-wise and usage differences are clear, they have a lot in common from the IDE synchronization perspective and are created using the same technologies. In this talk, we’ll be exploring the way such synchronization is performed, how one can separate an extremely big and complex system with tons of plugins into several parts; and what it takes to transform a single-user desktop application into a server capable of handling multiple clients.

       

  2. June 3. Online

  3. June 26. Offline + online

    • Watch recording
      Talk

      Distributed transactions implementation trade-offs

      This is educational first speech. Let's see why ACID transaction properties are important and how they are implemented in distributed databases with sharding and replication. What about geo-distributed databases? Is it possible to achieve fault tolerance (high availability) and support strong consistency in such databases. What are trade offs for performance. discuss famous CAP theorem and what it means for data indexing and DB transactions.

       

    • Watch recording
      Talk

      Memory as a Concept in Heterogeneous Systems

      Memory is something that C++ programmers know very well and think they have control over. But how much is known about memory on the GPU?

      Suddenly, many familiar concepts from the C++ world break down, and creating single-source abstraction layers (such as SYCL) requires introducing a lot of CPU-weird concepts and terms. And all this affects performance. In the talk, Konstantin will take a look at memory as it is understood in C++ and as it is understood for graphics and show a lot of examples on SYCL. 

    • Watch recording
      Talk

      Parallel Asynchronous Replication between YDB Database Instances

      Asynchronous replication is a well-known technique to provide an independent replica of a database for different purposes including disaster recovery, geo-replication or scaling read workload. Traditionally, a log of changes from source replica is treated as an input for target replica database. If source and target replicas are distributed databases that handle high workload, putting all updates to a single log of changes could be nearly impossible. 

    • Watch recording
      Talk

      Is there life without RTTI or how to write your own dynamic_cast

      C++ developers don't like to pay for something they don't use. But there is a nuance, RTTI. As soon as you write dynamic_cast in the code, and you have to pay for runtime type information. We will look at how you can reduce the overhead by implementing your own dynamic_cast without RTTI.

    • Lunch break

      Lunch break is at different times for different participants. Please refer to the printed program for details.

    • Watch recording
      Talk

      File system and network stacks in Userland: why we must use them in 2022

      IO-performance becomes increasingly important:

      • we have more and more cores,
      • PCIe Gen3 is finally turning into PCIe Gen5 and for now it stops being the bottleneck,
      • NVMe drives and 200G NICs means the network is faster and fast.

      Stacks that were OK in the past are not OK now. You can't saturate the HW IO capacity while doing context switches, wakeups in the kernel etc. So what before was an "option" is actually a MUST HAVE for most of the high performance applications.

    • Watch recording
      Talk

      What about Binary Search Trees?

      In this talk, we cover how to design concurrent Binary Search Trees starting from the simplest ones. Hopefully, after this talk, the attendee will understand the standard tricks necessary for the implementation of Binary Search Trees. These tricks are important and can help to implement other more complex data structures.

    • Watch recording
      Talk

      Using machine learning to improve inlining in LLVM

      Feature embedding (inlining) is an optimization that is based on the heuristics used to make the final decision about feature embedding. These heuristics are designed to make an efficient solution in the general case, but, as a consequence, can lead to far from efficient solutions in different from general cases. To solve this problem, LLVM has added support for using a machine learning model that answers the question, based on analysis of the compiled code, whether a function should be embedded into the call point in question. In this talk, we'll look at how this mechanism for determining whether a function should be embedded using machine learning works, how it can improve your program, and what its limitations are.

    • Watch recording
      Talk

      C++ compiler and optimizations for open RISC-V instruction set architecture

      Sergey will talk about C/C++ compiler and application optimization for the open and free RISC-V architecture, the new standard changing the microprocessor world. You will learn about the history of the architecture, current state and plans in the international RISC-V community, architecture support in development tools, source code and compiler optimizations and transformations, performance hints and command  system extensions.

    • Watch recording
      Talk

      How to make your life easier when developing a client application in modern C++: an example of VK Calls

      Developing the VK  Calls desktop application was a real challenge. The team set several goals at once: to provide native builds for Windows, macOS, and Linux, to achieve maximum performance and quality, while removing the limit on the number of participants in the call. And to do all this in the shortest possible time. To do this, we had to think in advance how to cut some of the sharp corners that inevitably arise during the development in  C++.

    • Watch recording
      Talk

      Thread pools: variety of algorithms and features

      This talk will help you dive into the various algorithms that have been implemented in Java, .NET, and other runtimes. We will consider the tasks they solve and learn to understand problem areas. Also, solving certain tasks, we will create our own thread pool, after which we will achieve its maximum performance.

    • Watch recording
      Talk

      Type Sanitizer: a way to detect violations of strict aliasing rules in C++

      This talk describes a dynamic analysis tool that allows detecting strict aliasing rules violation in C++ programs. This topic covers implementation details of this tool that is implemented as a part of LLVM infrastructure. The talk requires basic knowledge of LLVM middle-end part and common ideas of sanitizers (e.g. AddressSanitizer)  implementation.

    • Watch recording
      Talk

      What a C++ developer should keep in mind about processor architecture

      At high loads, code efficiency may be a much better investment than buying new resources. Let's look into the "under the hood" of the processor. We will see what the cache, the pipeline, the vector instructions are for, and also see what else is there. We will look at the differences between x86 and ARM. We will discuss what code should be able to get the most out of the processor and not wait for hundreds of cycles  for that byte to be loaded.

    • Watch recording
      Talk

      OK S3

      Vadim will describe implementation of S3 compatible storage service based on blob and NewSQL storages at Odnoklassniki. The talk will cover the architecture and data model, features and trade-offs, performance and optimization, some intricacies and surprises. The ideas and experience presented in the talk might be useful to designers and developers of distributed storage services, especially S3-compatible and/or Cassandra-based ones.

    • Watch recording
      Talk

      Overview of recent research in the field of selection of optimal sequences of optimization passes using ML

      Now the sequence of optimization passes is chosen with the help of peer review by the compiler developers using a certain set of benchmarks. This is a very difficult task and a huge search space that ML can help with. Roman and Maria will consider approaches to solving this problem. They will make reviews of research papers and the tools and models used, describing their advantages and disadvantages. They will also show what practical results are achievable using machine learning to select the optimal sequence of optimization passes.