The Complexity of Testing Message-Passing Concurrency

TL;DR

This paper investigates the computational complexity of testing message-passing concurrency in modern programming languages, providing a detailed landscape of tractability and intractability based on various input parameters.

Contribution

It extends the study of consistency testing from shared-memory models to channel-based message-passing, establishing complexity bounds and algorithms for verification.

Findings

Complexity landscape includes polynomial upper bounds for fixed parameters.

Hardness results identify minimal parameters leading to intractability.

Algorithms are nearly optimal for verifying channel consistency.

Abstract

A key computational question underpinning the automated testing and verification of concurrent programs is the consistency question - given a partial execution history, can it be completed in a consistent manner? Due to its importance, consistency testing has been studied extensively for memory models, as well as for database isolation levels. A common theme in all these settings is the use of shared-memory as the primal mode of interthread communication. On the other hand, modern programming languages, such as Go, Rust and Kotlin, advocate a paradigm shift towards channel-based (i.e., message-passing) communication. However, the consistency question for channel-based concurrency is currently poorly understood. In this paper we lift the study of fundamental consistency problems to channels, taking into account various input parameters, such as the number of threads executing, the number of channels, and the channel capacities. We draw a rich complexity landscape, including upper bounds that become polynomial when certain input parameters are fixed, as well as hardness lower bounds. Our upper bounds are based on algorithms that can drive the verification of channel consistency in automated verification tools. Our lower bounds characterize minimal input parameters that are sufficient for hardness to arise, and thus shed light on the intricacies of testing channel-based concurrency. In combination, our upper and lower bounds characterize the boundary of tractability/intractability of verifying channel consistency, and imply that our algorithms are often (nearly) optimal.