ConcurrencyLab.ParallelChecker 2.6.0

The Parallel Checker is a static analysis that detects data races, deadlocks and other concurrency issues in C#. The analysis is available as a NuGet package (e.g. for Visual Studio Code) and as a Visual Studio extension.

Visual Studio Code Integration

1. Install the C# extension in Visual Studio Code, if not yet done.

1. Menu "File"->"Preferences"->"Extensions"
2. Search for "C# for Visual Studio Code (powered by Omnisharp)" and install it.

2. Enable Roslyn analyzers in the setting.

1. Menu "File"->"Preferences"->"Settings"
2. Select "Extensions"->"C# configuration"
3. Go to section "Omnisharp: Enable Roslyn Analyzers"
4. Enable the option "Enable support for roslyn analyzers, code fixes and rulesets."

3. Add the NuGet package "ConcurrencyLab.ParallelChecker" to the desired C# projects.

1. Menu "Termin"-"New Terminal"
2. Enter "dotnet add package ConcurrencyLab.ParallelChecker"

4. Checker issues are displayed in the "problems" view and are also highlighted in the code

1. Menu "View"->"Problems"

5. If issues do not appear: Close and reopen the C# projects, wait for a moment, optionally run the project

Visual Studio Integration (VS 2022)

1. Open Visual Studio
2. Menu "Extensions"->"Manage Extensions"
3. Search for "Parallel Checker for C# 10 (VS 2022)" and install it
4. Close Visual Studio, follow the installer, and restart Visual Studio

More detailed instructions can be found at the VS Marketplace website of latest Parallel Checker.

Support for older VS 2019 is available at VS Marketplace website of Parallel Checker for VS 2019.

Concurrency Issues

The checker detects the following concurrency (multi-threading) issues with a static analysis, however, not necessarily all of them:

• Data Races: Unsynchronized concurrent accesses to same variable or array element, involving at least a write.
• Deadlocks: Constellations in which multiple threads block each other cyclically forever.
• Thread-unsafe usage: Unsynchronized concurrent calls or accesses of application programming interfaces that are not specified to be thread safe.

The abovementioned issues are all fundamental programming bugs that can lead to program errors. These issues occur non-deterministically, possibly sporadically or very seldom. They are therefore hard to identify in tests and are not easily reproducible. For this reason, it makes sense to use a static analysis that examines various program traces, including very specific or seldom cases, as to whether they suffer from such issues.

Samples

As a first starting point, you can try the sample C# solutions to detect data races and deadlocks. You can download the samples from https://github.com/blaeser/parallelchecker/tree/main/doc/samples

How It Works

The checker is implemented based on the compiler framework Roslyn and analyzes the C# source code without executing the program, called static analysis. It screens as many interesting program traces as possible within defined deterministic bounds. The analysis maintains exact and complete context information for the program, where possible. Exceptions are e.g. external input/output and missing or incorrect source code parts, in which case conservative assumptions are made. The properties of the checker can be summarized as:

• Precise: Real issues are reported without false positives (no false alarms), except when making conservative assumptions.
• Incomplete: The checker may miss potential issues (possible false negatives) as there exists no precise and complete analysis.
• Deterministic: The same issues are repeatedly reported for the same program.

The checker engages a new algorithm. It has been designed to efficiently deal with large software projects and find as many issues with high precision as possible.

More Information

You can find more information on the checker website https://github.com/blaeser/parallelchecker