Comprehensive Overview of Polyspace R2021a Polyspace R2021a is a major release from MathWorks that enhances static code analysis workflows for safety-critical C and C++ embedded software. This release focuses on increasing analysis speed, improving precision for specific automotive standards, and introducing new tools to manage code complexity. Key Features and Improvements in R2021a
The R2021a update introduced several critical capabilities across the Polyspace Bug Finder and Polyspace Code Prover product lines:
Mixed C/C++ Analysis: You can now run Polyspace Code Prover on projects containing a mix of C and C++ source files without needing to separate them into different verification runs.
AUTOSAR Support: The release offers faster and more precise analysis for C/C++ code utilizing the AUTOSAR RTE API. By using the new -library autosar option, Polyspace employs "smart stubs" for library functions, improving performance without sacrificing verification rigor.
Guidelines Checkers: A new category of customizable checkers in Polyspace Bug Finder allows you to monitor quantifiable code complexity metrics, such as cyclomatic complexity and path counts, helping detect overly complex modules early in development.
Polyspace Query Language (PQL): This release supports PQL, a powerful tool for creating user-defined defect checkers and custom coding standards tailored to specific project requirements.
Enhanced Integration: R2021a supports modern compilers like Visual Studio 2019 and GCC 8.x, and simplifies the process of starting analysis on code generated from Simulink without needing to manually generate the code first. Core Benefits for Embedded Software
Polyspace distinguishes itself through the use of formal methods to achieve high software quality standards:
What’s New in Polyspace R2021a? - MATLAB & Simulink - MathWorks
Polyspace R2021a: A Comprehensive Write-up
Introduction
Polyspace R2021a is a software tool developed by MathWorks, designed to help engineers and developers detect and fix errors in their code. As a static code analysis tool, Polyspace R2021a enables users to analyze C, C++, and Ada code for runtime errors, security vulnerabilities, and coding standard compliance. In this write-up, we will explore the features, benefits, and applications of Polyspace R2021a.
Key Features
Benefits
Applications
Conclusion
Polyspace R2021a is a powerful static code analysis tool that helps developers detect and fix errors, security vulnerabilities, and coding standard violations. With its comprehensive feature set, Polyspace R2021a is an essential tool for industries that require high levels of reliability, security, and quality in their software. By using Polyspace R2021a, developers can ensure that their code is reliable, secure, and maintainable, ultimately leading to improved productivity and reduced costs.
In Polyspace R2021a, reports are used to document the results of static analysis for C and C++ projects, typically covering defects, coding standard violations, and code metrics Report Types and Contents The R2021a release of Polyspace Bug Finder Polyspace Code Prover allows you to generate several types of reports: Defect Reports
: Lists all identified software bugs such as numerical issues (e.g., divide-by-zero), static and dynamic memory issues, and security vulnerabilities. Coding Standard Compliance
: Documents violations of standards like MISRA C:2012, MISRA C++, or AUTOSAR. Code Metrics
: Provides data on software complexity, including cyclomatic complexity and lines of code. Project Summaries
: A high-level overview of analysis settings, definitions, and a summary of findings per file. Key Updates in R2021a
The R2021a release introduced specific enhancements for reporting and analysis workflows: Mixed Code Support
: Analysis can now be run on projects containing a mix of C and C++ source files. Customizable Checkers
: New guidelines checkers allow for more personalized software complexity reporting. AUTOSAR Support
: Improved performance and precision for code using the AUTOSAR RTE API. Managing Reports Collaborative Review : Users often use Polyspace Access
to review results on a web-based interface, which facilitates collaboration between developers and QA teams. Automation
: Analysis and report generation can be integrated into CI/CD pipelines (e.g., using Bamboo) to automatically push results to issue trackers like Customization
: While Polyspace provides standard templates, users can often customize report content to meet specific OEM or regulatory requirements. MATLAB EXPO troubleshoot an error in an existing one?
fixed point type is not supported" in POLYSPACE R2021a - MathWorks
Polyspace R2021a is a major update to the MathWorks static code analysis suite, designed to help developers prove the absence of critical run-time errors and uncover defects early in C and C++ projects. This release focuses on performance optimizations for large-scale embedded systems, particularly those using the AUTOSAR standard, and introduces new tools to manage code complexity. Key Advancements in Polyspace R2021a
The R2021a update delivers refinements across the entire Polyspace product line, from local IDE plugins to centralized web-based reporting.
Enhanced AUTOSAR Support: Polyspace Code Prover™ now runs faster and provides more precise results for code using the AUTOSAR RTE API. A new -library option allows for "smart stubs" that target AUTOSAR-specific checks without the overhead of checking the entire library implementation.
Mixed C/C++ Projects: Developers can now run a single Polyspace Code Prover analysis on projects containing a mix of C and C++ source files, simplifying the verification of modern multi-language codebases.
New Guidelines Checkers: A new category of customizable checkers in Polyspace Bug Finder™ helps teams monitor software complexity. These checkers track metrics like cyclomatic complexity and the number of paths to identify "heavy" modules that require refactoring before they become maintenance burdens.
Cross-Release Workflow: With R2021a, users can analyze code generated in earlier releases of Simulink® (R2020b or later) using the new pslinkrunCrossRelease function, allowing teams to upgrade their analysis tools without needing to migrate their entire model-based design environment immediately. Collaborative Analysis with Polyspace Access polyspace r2021a
For team-based development, Polyspace Access™ introduces several UI and workflow improvements in R2021a to streamline result triage.
Custom Filters: Users can define and share custom filter groups, allowing organizations to focus on the specific findings most relevant to their internal safety or security standards.
Results Comparison: The web interface now includes a filter to view findings from a baseline run that have been fixed in the current run, providing clear evidence of progress during remediation.
Optimized Code Review Layouts: A new default Code Review layout prioritizes the source code view, making it easier for developers to investigate the root cause of issues directly in the browser. Expanded Language and Compiler Support
To support modern development environments, R2021a expands its compatibility with industry tools:
Compilers: Added support for Visual Studio 2019 and GCC 8.x.
Standards Compliance: Expanded coverage for AUTOSAR C++14, CERT C++, and MISRA C++ rules.
PQL (Polyspace Query Language): Users can now create their own custom defect checkers and coding standards using PQL, which supports a new .pql file format and a dedicated command-line tool. The "Shift Left" Philosophy Polyspace Notes - MATLAB & Simulink - MathWorks
In Polyspace R2021a, there isn't a feature to "generate a story" in a literary sense. Instead, you likely want to generate a report or "story" of your code analysis to share with stakeholders.
Here is how you can generate a professional report of your results: Generate a Report from the UI
Open Results: Load your analysis results in the Polyspace Platform.
Select Reporting: Go to the Reporting menu and click Run Report.
Choose a Template: Select from predefined templates like BugFinder or CodeMetrics. Set Format: Choose your output format (PDF, Word, or HTML). Run: Click Run to save the report to your output folder. Generate a Report via Command Line
If you are automating your workflow, use the polyspace-report-generator command:
polyspace-report-generator -results-dir -results-dir: Path to your verified code results. -format: Standard formats are PDF, Word, and HTML. -output-name: Name your "story" file. 💡 Key Highlights in R2021a
Custom Templates: You can customize existing templates to include only specific "stories" like memory safety or coding standards (MISRA/AUTOSAR).
New Guidelines: R2021a introduced "Guidelines" checkers to track code complexity stories, helping you spot spaghetti code early.
Combined Results: You can now generate a single "story" that combines both Bug Finder (coding rules) and Code Prover (runtime errors) results. If you'd like, I can help you: Customize a template to show specific bug types.
Set up an automated script to generate reports after every build.
Interpret specific results like "Cyclomatic Complexity" or "Red Zones."
Let me know which part of your code's story you want to focus on! What's New in Polyspace R2021a? - MATLAB & Simulink
Unlocking the Power of Polyspace R2021a: A Comprehensive Review
In the realm of software development, ensuring the reliability and safety of code is paramount. As systems become increasingly complex, the need for robust verification tools has never been more pressing. MathWorks, a renowned leader in software development solutions, has been at the forefront of this challenge. With the release of Polyspace R2021a, the company continues its tradition of delivering cutting-edge technology designed to help developers create more reliable and efficient code.
What is Polyspace R2021a?
Polyspace R2021a is a static code analysis tool designed to verify the correctness and reliability of code written in languages such as C, C++, and Ada. Part of the MathWorks' suite of software development tools, Polyspace is engineered to help developers detect and eliminate errors early in the development process, significantly reducing the risk of downstream bugs and vulnerabilities.
Key Features of Polyspace R2021a
The latest iteration of Polyspace, R2021a, comes with a host of improvements and new features aimed at enhancing the user experience and the accuracy of code analysis.
Improved Code Analysis Capabilities: Polyspace R2021a offers enhanced algorithms for code analysis, providing deeper insights into code behavior and more accurate detection of potential issues.
Support for Latest Standards: The tool supports the latest industry standards for coding, including MISRA C 2012, MISRA C++ 2008, and Ada 2012, ensuring compliance with regulatory requirements.
Enhanced User Interface: The R2021a version introduces a more intuitive and user-friendly interface, making it easier for developers to navigate through analysis results, identify issues, and prioritize fixes.
Integration with Other Development Tools: Polyspace R2021a seamlessly integrates with other MathWorks tools and third-party software development environments, facilitating a smoother workflow and enhancing productivity.
Enhanced Performance: The tool has been optimized for performance, offering faster analysis of large codebases without compromising on accuracy.
Benefits of Using Polyspace R2021a
The advantages of utilizing Polyspace R2021a in software development projects are multifaceted:
Enhanced Code Quality: By identifying and fixing errors early in the development cycle, Polyspace R2021a helps ensure that the final product is of higher quality and reliability. Static Code Analysis : Polyspace R2021a performs a
Compliance with Industry Standards: The tool's support for various coding standards helps developers adhere to regulatory and industry-specific coding guidelines, reducing the risk of non-compliance.
Increased Productivity: The intuitive interface and integration capabilities of Polyspace R2021a mean that developers can focus on coding rather than debugging, leading to increased productivity.
Reduced Development Costs: By catching bugs early, developers can avoid the significant costs associated with fixing errors later in the development process or in the field.
Improved Safety and Security: Polyspace R2021a's ability to detect potential vulnerabilities helps in creating safer and more secure software systems.
Real-world Applications of Polyspace R2021a
Polyspace R2021a finds applications across various industries where code reliability, safety, and security are critical. Some of these include:
Automotive: For developing safety-critical systems in vehicles, such as autonomous driving software.
Aerospace: In the development of flight control systems, navigation software, and other safety-critical applications.
Medical Devices: For ensuring the reliability and safety of software used in medical devices.
Industrial Automation: In creating control systems for industrial machinery and processes.
Getting Started with Polyspace R2021a
For developers and organizations looking to leverage the capabilities of Polyspace R2021a, MathWorks provides comprehensive resources:
Tutorials and Documentation: Extensive guides and tutorials are available to help users get started and make the most of the tool's features.
Training and Support: MathWorks offers training sessions and customer support to assist with any questions or challenges users may encounter.
Free Trials: Prospective users can access free trials to evaluate Polyspace R2021a's capabilities firsthand.
Conclusion
Polyspace R2021a represents a significant advancement in static code analysis technology, offering developers a powerful tool to ensure their code meets the highest standards of reliability, safety, and security. With its enhanced features, improved performance, and seamless integration with other development tools, Polyspace R2021a is poised to play a critical role in the development of complex software systems across various industries. By adopting Polyspace R2021a, developers and organizations can not only streamline their development processes but also significantly improve the quality and reliability of their software products.
The Polyspace R2021a release from MathWorks introduced significant advancements in handling complex C/C++ projects, particularly for safety-critical and automotive industries. This version focused on speed, mixed-language support, and expanded compliance for international safety standards. Key Features & Major Updates
Mixed C/C++ Analysis: Polyspace Code Prover now supports projects containing both C and C++ source files simultaneously. By using the -lang C-CPP option, the tool compiles and verifies them as a unified C++ project, eliminating the need to separate files.
AUTOSAR Enhancements: Analysis of code using the AUTOSAR RTE API is faster and more precise. New "smart stubs" for AUTOSAR libraries allow users to check for standard compliance without losing precision or needing complex manual setups.
New "Guidelines" Checkers: Polyspace Bug Finder introduced a new category for software complexity. These customizable checkers measure metrics like cyclomatic complexity and the number of execution paths, helping developers identify and refactor overly complex modules early.
Expanded Coding Standards: Support was added for additional rules within AUTOSAR C++14, CERT C++, and MISRA C++.
Cross-Release Workflows: Users can now use Polyspace R2021a to analyze code generated in previous versions of Simulink (starting from R2020b) using the pslinkrunCrossRelease function. Usability and Integration
Compiler Support: Added official support for Visual Studio 2019 and GCC 8.x compilers.
Simplified Setup: The integration process between Polyspace and MATLAB/Simulink was streamlined to require fewer steps.
Polyspace Access Improvements: Features enhanced logging for services within the Admin UI, aiding team collaboration and project tracking. Core Tool Comparison Polyspace R2021a continues to rely on two primary engines: What's New in Polyspace R2021a? - MATLAB & Simulink
Polyspace R2021a is a significant update from that focuses on speed, automated compliance for automotive standards, and improved developer workflows within Key Features & Enhancements Enhanced AUTOSAR Support Polyspace Code Prover
in R2021a delivers faster and more precise analysis for C/C++ code using the AUTOSAR RTE API
. It allows for AUTOSAR standard compliance checks without special setup for compliant code. Mixed-Language Analysis
: Users can now run a single analysis on projects containing a mix of C and C++ source files
. Polyspace automatically compiles each file type and verifies them collectively as a C++ project. Customizable "Guidelines" Checkers : New to the Polyspace Bug Finder , these checkers detect software complexity
metrics—such as cyclomatic complexity and number of paths—early in the development cycle to reduce future refactoring needs. Cross-Release Integration
: This version introduces the ability to analyze code generated in older
releases (R2020b or later) using the newer R2021a Polyspace tools via the pslinkrunCrossRelease Expanded Tool Support : R2021a adds support for Visual Studio 2019 and GCC 8.x compilers, along with updated rules for AUTOSAR C++ 14 Pros & Cons Simultaneous Analysis
: Can check for MISRA compliance and functional defects in a single run Runtime errors (e
: The Polyspace Code Prover's deep formal methods analysis remains relatively slow
, which can hinder adoption in high-frequency CI environments. IDE Integration : Capabilities are brought directly into the
, allowing developers to find bugs before code is even committed. Configuration Complexity : Managing detailed configurations
for complex scenarios like multitasking interrupt priorities can be challenging. Mathematical Proof : Unlike standard checkers, it mathematically proves the absence of critical runtime errors. Customization Limits : Some users note limitations in customizing MISRA rule categories (e.g., Mandatory vs. Required).
Polyspace R2021a is an essential upgrade for teams working in safety-critical sectors like automotive (ISO 26262)
or aerospace. While the Code Prover's exhaustive analysis still demands significant time, the addition of IDE plugins automated AUTOSAR support
makes static verification more accessible and less disruptive to the daily development flow. SciEngineer Guidelines checkers
What’s New in Polyspace R2021a? - MATLAB & Simulink - MathWorks
Code Prover’s formal analysis is computationally expensive. R2021a introduced a parallelization engine that automatically partitions analysis jobs across multiple cores. Benchmarks show a 40% reduction in analysis time for aerospace flight control logic tested on 8-core machines.
This release focused on workflow automation, C++17 support, and UI improvements.
| Codebase (LOC) | Tool | R2020b time | R2021a time | Memory Δ | |---------------|------|-------------|-------------|-----------| | 200k (C, automotive) | Code Prover | 28 min | 24 min | -8% | | 500k (C++, aerospace) | Bug Finder | 17 min | 14 min | -5% | | 50k (C, MISRA) | Bug Finder | 4.2 min | 3.5 min | -10% |
Platform: Intel Xeon E5-2680 v4, 64 GB RAM, SSD.
| Task | Command |
|------|---------|
| Run Bug Finder on folder | polyspace-bug-finder -sources . -target-compiler gcc10 |
| Run Code Prover with entry point | polyspace-code-prover -sources main.c -entry-points main |
| Generate HTML report | ... -generate-html-report -html-report-folder ./report |
| Apply MISRA 2012 | -checkers-selection "MISRA_C_2012" |
| Exclude a file | -exclude-files "test/*.c" |
| Use baseline (suppress old bugs) | -baseline-results results.pscp |
| Merge results from multiple runs | polyspace-report-generator -merge file1.pscp file2.pscp -output merged.pscp |
Document version: 1.0
Last reviewed: Based on official MathWorks R2021a documentation and field experience.
Suggested retention: Use until at least R2023b for reference; check MathWorks website for end-of-maintenance date (typically 3 years after release).
Polyspace R2021a: Advancing Static Code Analysis for Safety-Critical Systems
Polyspace R2021a, developed by MathWorks, introduces significant enhancements to its static analysis suite to improve the safety, security, and reliability of embedded software. This release focuses on faster analysis times, expanded coding standard support, and better integration for complex C++ and AUTOSAR projects. Key Feature Enhancements in R2021a 1. New Guidelines Checkers for Code Complexity
R2021a introduces a new category of Guidelines checkers specifically designed to manage and reduce software complexity.
Quantifiable Metrics: These checkers monitor metrics such as cyclomatic complexity and the number of execution paths.
Early Detection: By identifying complex modules early, developers can refactor code before it becomes a maintenance or safety liability.
Standard Compliance: The suite supports HIS (Hersteller Initiative Software) recommended thresholds for these complexity checkers. 2. Improved AUTOSAR Support
For automotive developers, this release significantly optimizes workflows involving the AUTOSAR standard.
Faster RTE Analysis: Polyspace Code Prover now runs faster and provides more precise results for C/C++ code utilizing the AUTOSAR RTE API.
Smart Stubs: The analysis uses "smart stubs" for AUTOSAR library functions, reducing the need for manual setup while maintaining high precision. 3. Mixed C and C++ Analysis
Polyspace Code Prover now natively supports projects containing a mix of C and C++ source files.
Seamless Compilation: The tool automatically compiles C files as C and C++ files as C++, then verifies the entire project as a unified C++ entity.
Reduced Overhead: Developers no longer need to separate these files to achieve successful compilation and verification. Product Suite Comparison What's New in Polyspace R2021a? - MATLAB & Simulink
Polyspace R2021a represents a significant milestone in the evolution of static code analysis, specifically within the MathWorks ecosystem. As a tool designed for the formal verification of C, C++, and Ada source code, R2021a introduced critical enhancements that bridged the gap between rigorous mathematical proof and the practical needs of modern DevOps workflows. The Core Value Proposition
At its heart, Polyspace R2021a utilizes "abstract interpretation," a formal method that allows the tool to prove the absence of specific run-time errors (like overflow, divide-by-zero, or out-of-bounds access) without actually executing the code. Unlike traditional "bug hunters" that rely on heuristics to find likely errors, Polyspace provides a level of certainty—categorizing code into green (safe), red (error), gray (unreachable), and orange (unproven) zones. This exhaustive analysis is vital for safety-critical industries such as automotive (ISO 26262), aerospace (DO-178C), and medical devices. Key Innovations in R2021a
The R2021a release focused heavily on accessibility and integration. Key features included:
Polyspace Access: This release strengthened the web-based interface, allowing developers and project managers to review results without needing a local installation. This shifted the tool from a specialist’s workstation to a collaborative team environment.
Jira Integration: R2021a streamlined the remediation process by allowing users to export identified defects directly into Jira. This integrated security and quality checks into the standard project management lifecycle.
Expanded Coding Standards: The update provided enhanced support for MISRA C:2012 and AUTOSAR C++14, ensuring that code not only ran without errors but also adhered to industry-standard stylistic and safety guidelines.
Performance Improvements: This version introduced faster analysis engines and better support for incremental analysis, addressing the common criticism that formal verification is too slow for rapid development cycles. Impact on the Development Lifecycle
Polyspace R2021a moved formal verification "to the left" of the development cycle. By integrating with build systems and providing clear dashboards, it allowed teams to identify "unprovable" code segments long before they reached the integration or testing phases. This reduces the cost of fixing bugs, which increases exponentially as code moves toward production. Conclusion
Polyspace R2021a is more than just a bug finder; it is a quality assurance powerhouse. By combining the "exhaustiveness" of formal methods with the "connectedness" of modern software tools, it provides a comprehensive solution for developers who cannot afford to be wrong. It remains a definitive example of how complex mathematical analysis can be packaged into a usable, collaborative, and essential part of the software engineering toolkit.
auto, rvalue references, constexpr).