Petrify: Petri-net Based Analysis of Concurrency Properties in Java Bytecode

2026-07-01

AI Summary

This work addresses the challenge of efficient and scalable formal verification of concurrency properties—such as deadlock—in Java bytecode by proposing a Petri net–based modeling and analysis approach. The method precisely encodes bytecode semantics into Petri nets and leverages the mature model checker LoLA to enable automated verification of concurrent behaviors. Notably, this is the first application of Petri nets to concurrency analysis of Java bytecode, supporting multiple Java versions and partial Kotlin programs, thereby overcoming language-version limitations of existing tools. The prototype implementation, jPetrify, demonstrates high precision and strong scalability in verifying fundamental concurrency properties like deadlock, with performance largely insensitive to parameter scale.

Abstract

The landscape of automated formal verification is populated by techniques that make prominently different trade-offs: some focus on expressiveness and precision, supporting the verification of complex properties; others favor scalability and practicality, so that they are applicable to larger programs using different features. This paper presents Petrify, a novel automated verification technique for concurrency properties that achieves a distinctive trade-off. Petrify encodes the semantics of Java bytecode programs into Petri nets (PNs), which can be analyzed by state-of-the-art model checking tools such as LoLA. As our experiments demonstrate, Petrify's approach offers an interesting combination of expressiveness and practicality: PNs are a fairly precise encoding of the concurrent behavior of programs; at the same time, Petrify's PN encoding is succinct, so that its analysis remains quite insensitive to parameter size. Another practical benefit of targeting bytecode is that jPetrify, the prototype tool that implements the Petrify technique, is applicable to programs written in any version of Java and even a subset of Kotlin (another language that compiles to Java bytecode) while other similar tools are limited to older versions of Java. While this paper's experiments focus on analyzing fundamental properties like deadlock, Petrify's approach lends itself to be extended to other kinds of concurrency analysis, which we plan to tackle in future work.

Problem

• concurrency verification
• Java bytecode
• formal verification
• Petri nets
• automated analysis

Innovation

• Petri nets
• Java bytecode
• concurrency verification
• automated formal verification
• model checking