Only those projects where I had a key role are presented here. For each of the projects short descriptions, links to my blog posts, publications, and talks are attached.


Tool for detecting potential lags in UI threads

This tool finds potentially long operations invocations in UI thread. The long operation is determined as a method, which needs access to filesystem or network. The approach is based on two main techniques – applying static analysis to widen the scope of detection and run-time code instrumentation to detect violations on the fly. Static analysis phase detects methods that contain potentially long operations on a Function Call Graph (FCG) and marks them as “long”. Collected data is used by the run-time part to widen the scope of analysis and report if a long operation is invoked in UI thread. The run-time analysis also detects if UI thread may be blocked too long due to acquiring a lock which could be held during a long operation invocation.


Framework for testing concurrent algorithms for correctness

Lin-check is a framework for testing concurrent data structure for correctness. In order to use the framework, operations to be executed concurrently should be specified with the necessary information for an execution scenario generation. With the help of this specification, Lin-Check generates different scenarios, executes them in concurrent environment several times and then checks that the execution results are correct (usually, linearizable, but different relaxed contracts can be used as well).

Lock-free algorithms testing


Tool for finding potential deadlocks via dynamic analysis

Dl-Check determines potential deadlock as a lock hierarchy violation and finds them via dynamic analysis in Java programs. This tool is implemented as Java agent and injects analysis code within class transformation during class loading, therefore it’s possible to use Dl-Check without any code change. The base algorithm for finding lock hierarchy violations is based on new cycles detection in the lock-order graph. For this purpose, an algorithm for incremental topological order maintenance is used. However, existing solutions are not efficient for concurrent execution, so currently I am working on scalable topological order maintenance algorithm.

How to find deadlock not getting into it

Dl-Check: dynamic potential deadlock detection tool for Java programs


Tool for finding code usages among Maven repositories

Usages tool finds code usages in the specified Maven repositories. It indexes repositories, downloads required artifacts and scans “.class” files in them. The tool analyzes all kinds of dependencies: usages of fields and methods, extensions of classes and implementations of interfaces, usages of annotations, overrides of methods. The tool is separated into 2 parts: server application, which collects all information and analyzes classes, and a client one, which is implemented as IntelliJ Plugin.


Library for testing time-based functionality in Java programs

Time-test helps to test time-dependent functionality via time virtualization. It is implemented as a Java agent and replaces all time-dependent methods invocations with its own implementations. Unlike other implementations, it works not with System.currentTimeMillis() and System.nanoTime() methods only, but with Object.wait(..), Thread.sleep(..), and Unsafe.park(..) as well. In addition, time-test has a special waitUntilThreadsAreFrozen(timeout) method which waits until all threads have done their work.

Time machine for Java


Framework for simplifying java agents development

TODO short description