Talks

The goal of this talk is to get you familiar and comfortable with the ins and outs of a basic implementation of type erasure in C++.

Using an implementation of a value wrapper for polymorphic types as an example, we'll examine how type erasure works that is similar to `std::any`.

We will consider a new tool — LLVM MemProf, how it works under the hood, and other memory profiling techniques.

The talk will include some ideas on slow and complex patterns, ideas on speeding them up, and debunking some myths.

Let's see how to use the profile in optimizations and how to help the compiler without the profile.

The obvious and not-so-obvious problems of using Conan in large ecosystems. And solutions, without which integrating the package manager will only make things worse.

How to avoid making synchronization of frequent write operations a bottleneck of your program? This talk presents to you the sharding strategy, compares it with other synchronization methods and argue that synchronization optimization is more than switching to lock-free.

Multithreaded programming on ARM mobile processors has many pitfalls and differences from Intel. Because of this, theoretical expectations for adding multithreading can differ significantly from the actual performance impact.

I'll tell you about the very complex problems we encountered while developing the userver, and about unexpectedly simple solutions.

Traditionally, building a C++ project is a non-trivial task and not every build system can handle it. Despite their great diversity, it can be difficult to choose the best one for your project: incremental build, profiles, toolchains, custom targets, IDE integration, artifacts. In the talk, we will deal with their variety and nuances. 

I will talk about the importance of small optimizations that can significantly improve performance. There will be many examples of various application optimizations, including ClickHouse.

How does the compiler know what all these words in the program mean? Let's find out.

Basic concepts and operations in Asio using coroutines as an example.

Based on the teaching of Compiler Construction course in the leading IT universities of the country, we will discuss the most important aspects of such a course design - fundamental grounds, prerequisites, and approaches to class organization, including practical assignments for students.

We'll look at the motivation for modules in C++, their interaction with name resolution, and the complexities of maintaining them in development tools.

My talk focuses on backend performance in C++ with an alternative to boost::asio for massively parallel networking. Boost::asio is the de facto standard for C++ network code, but in rare cases it isn't available or enough due to various reasons. Drawing from experience on high-performance projects, I've developed a new task scheduling algorithm, built a networking library around it, and present them here. Key features include fair CPU scheduling, C++ coroutines support, formal verification with TLA+, and reproducible benchmarks showing N times speed up over boost::asio. The project is open-source and available at https://github.com/Gerold103/serverbox.

I will talk about how I wrote a codgen of C++ code in userver to describe JSON Schema, what problems I encountered and what interesting solutions I got. The story will be interesting for everyone who is interested in C++ templates and their use in production code.

I'll talk about how LLVM-based compilers (e.g., Clang) model undefined behavior and how to benefit from it.

A talk about the evolution of work on the performance of 2GIS mobile application: what tools we use, how the process is organized, what we have achieved.

We will consider the application of template-based meta-programming and the “strong” object-oriented type system based on it in C++23 to improve the reliability of software engineering in spacecraft and launch vehicle ballistics problems.

The talk will cover such microarchitectural optimization as code reordering. We will discuss how compilers do it and try to do it manually in assembler on the example of Nvidia video cards.

Some classical algorithms vectorized, explained on a high level. memcmp, copy_if, set_intersection, sort. In pictures.

Modern processors are extremely complex devices designed to get maximum performance out of the code we run on them. The concepts of Out of Order (OoO), Super Scalar are all around us, and many people know about Branch predictor, but few people have any idea how it is organized. So let's understand how it works and where the processor gets its performance from!