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).
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.
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.nanoTime() methods only, but with
Unsafe.park(..) as well. In addition, time-test has a special
waitUntilThreadsAreFrozen(timeout) method which waits until all threads have done their work.
Framework for simplifying java agents development
TODO short description