How Static Analysis Identifies Concurrency Defects

The Mars Rover is one of the most sophisticated systems ever developed in human history. Designed and built by NASA engineers, it involved break-through innovations in mechanical engineering, hardware design, and used software to achieve the audacious goal of having a rover land on a planet that is, at its closest point, about 54.6 million kilometers away from the earth, then powering itself up and exploring Mars by collecting pictures and other data. Unfortunately, this miracle of human innovation had a software glitch due to a complex programming defect know as a race condition.

As our dependence on software grows, so does the sheer size of software and its complexity. Software is used to achieve essential functionality in everything from the latest games on the smart phones to sophisticated control systems in airplanes. Consumers demand more from the devices and services and anticipate a seemingly endless expansion of capabilities from their software. For the last 45 years of computing, Moore's Law has held true, with the number of transistors available in an integrated circuit doubling approximately every two years.

This constant pace of innovation provided software developers with critical hardware resources, enabling them to expand the features and functionalities of their applications without concern for performance. However, while Moore's Law is still holding steady, single-core processing has reached its performance ceiling. In response, hardware manufacturers have developed new multi-core (or multi-processor) devices to accomplish the speed gains to which the world has grown accustomed.

One of the most fascinating things about software development is that every opportunity introduces a unique challenge that developers need to addressin order to fully exploit its capabilities. To fully leverage this new class of multicore hardware, software developers must change the way they create applications. By turning their focus to multi-threaded applications, developers will be able to take full advantage of multicore devices and deliver software that meets the demands of consumers and IT departments. However, this paradigm of multi-threaded software development adds a new wrinkle of complexity by making it possible to introduce concurrency errors such as race conditions and deadlocks that are unique to multi-threaded applications. Complex and hard-to- find, these defects can quickly derail a software project. To avoid catastrophic failures, software development organizations must understand how to identify and eliminate these deadly problems early in the application development lifecycle.

Code testing with modern static analysis provides a solution that not only allows developers to identify and fix concurrency defects in new code, it also provides a cost-effective and automated way to uncover such defects in software that is being ported to run on multi-threaded processors. Let's understand this using a few examples.