My talks

The talks are arranged in themes. Some talks were given multiple times, choose the most recent one.

Hardware transactional memory in Java

:ru: Latest: JPoint 2018
:ru: Slides

This talk is devoted to the transactional memory, which you can meet in modern processors more and more often and which is supposed to make the world of concurrency a better place. Both possible ways to use it and the already existing optimizations in OpenJDK based on it, along with the possibility to run transactions directly from Java code are discussed.

On the way to efficient concurrent hash table

:ru: Latest: JBreak 2018
:ru: Slides

Nowadays, hash tables are probably the most used data structures, the performance of which influences many application’s components. However, is it that simple to write a fast implementation which uses all power of multi-core architectures? How efficient are the standard solutions in Java? We will try to get the answer to these and many other questions during this talk. We will touch on both theoretical aspects and some practical approaches for high-performance algorithms development.

Lock-free algorithms testing

:ru: Latest: Joker 2017
:ru: Slides

Writing multithreaded programs is hard, however, testing them is not easier at all. Thinking about all dangerous execution scenarios and writing tests for them is a difficult task, therefore it is often limited to a simple set of stress tests that are not always enough to detect an error. In order to solve this problem, the Lin-Check tool has been developed, which automatically checks a multithreaded Java code for linearizability. The first part of the talk is dedicated to various strategies and techniques for checking for linearizability. In the second part, we discuss the provided API and its ability to test your data structures.

Historical materials

:ru: SECR 2017: slides and video

How to find deadlock not getting into it

:ru: Latest: JEEConf 2017
:gb: Slides

Deadlocks are one of the main problems in multithreaded programming. This talk presents Dl-Check – a novel tool for detecting potential deadlocks at runtime of Java programs. In order to implement this tool, the bytecode instrumentation is required as well as the ASM framework is advantageous. In the first part of the talk, the general approach and the algorithm for online detection of potential deadlocks are presented. As for the second part, byte-code instrumentation and several useful techniques and associated cases related to it are discussed.

Historical materials

:ru: JPoint 2017: slides and video
:ru: JBreak 2017: slides and video