Parallelware Analyzer
Appentra’s Parallelware Analyzer is the first static code analyzer that is designed specifically to boost the performance of C/C++ code.
Earlier generations of source code analysis are limited to bugs, coding standard enforcement or security, possibly even a combination of this functionality. While important, nothing is done to ensure that the code is written to take advantage of modern hardware capabilities offered by chip manufacturers in the low-power multicore processors.
Performance Optimization Report
Parallelware Analyzer provides a performance optimization report with human-readable actionable items: opportunities, recommendations, defects, and remarks.
The information is displayed at the function level and at the loop level, followed by a code coverage summary and a performance metrics summary. You can control the amount of detail to be displayed and you will get clear suggestions on what your next actions should be, no matter whether they correspond to code changes or further invocations of Parallelware Analyzer to dig into more information.
How does it impact the development workflow?
Parallelware Analyzer usage is similar to any other static code analysis tool. It provides several command-line tools that can be invoked by the programmer from the operating system terminal, by the Integrated Development Environment (IDE) upon modification and compilation of the source code, as well as by the Continuous Integration (CI) and Continuous Delivery (CD) frameworks that automate software testing.
As the first static code analyzer specializing in performance, Parallelware Analyzer helps following performance optimization common practice by the programmer. Boosting the performance of software is an iterative process guided by the identification of the performance bottlenecks and hotspots of the code. This process repeats until the performance requirements of the project are met. The integration of Parallelware Analyzer is as follows:
1
Set up Parallelware Analyzer to enable the analysis of large scale codes
- Set up interoperability with build systems (e.g. CMake, Makefile) to get compiler flags
- Set up inter-procedural analysis across source files to manage file dependencies
- Set up third-party tools to integrate messages reported by the tools
2
Boost the performance focusing on the bottlenecks and hotspots
- Identify the hotspot of the code using a profiling tool.
- Compile the hotspot code using a compiler tool.
- Run the hotspot code to measure the performance baseline.
- Invoke Parallelware Analyzer to get a performance optimization report with human-readable actionable hints to tune the code to increase its performance. Get opportunities (OPP), recommendations (PWR), defects (PWD), remarks (RMK) and more code insights.
- Modify the source code following the instructions provided by Parallelware Analyzer
- Recompile and run the hotspot code to measure the performance improvement
Consult the open catalog of actionable items specializing in performance
The actionable insights provided by Parallelware Analyzer will guide the developer on how to invoke the pwreport, pwloops, pwdirectives and pwtrainer tools in order to boost the performance of the code on vector, multicore and accelerator processors.
Check the step-by-step guide 
on how to use Parallelware Analyzer tools to speedup the matrix multiplication code.
How does it work internally?
Parallelware Analyzer advances the state of the art of static code analyzers in order to tackle the performance optimization problem. It provides several command-line tools and a graphical user interface that leverage the Parallelware Artificial Intelligence engine through the LIBPW Application Program Interface (API). Inside LIBPW, the Parallelware middle-end is responsible for the analysis of the source code and the Parallelware back-end is responsible for the rewriting of the source code using compiler directives specializing in parallel computing for vector, multicore and accelerator processors. In order to parse C/C++ and Fortran source codes, the Parallelware Generic Front-End defines the programming language subset to be supported by the LLVM compiler intermediate representation produced by the CLANG C/C++ compiler front-end and the FLANG Fortran compiler front-end.
The Parallelware middle-end advances the state-of-the-art in static code analyzers through a proprietary pattern-based Artificial Intelligence engine that takes the analysis of the source code to a new level. Existing tools fit into levels 1, 2 and 3. Typically, level 1 covers simple stylistic and code formatting issues only by using pattern-matching techniques, while level 2 exploits the classical data-flow analysis technology to detect semantic issues across all the potential execution paths of the code. Data-flow analysis is slow for real applications, requiring minutes or even hours to finish. Thus, level 3 combines data-flow with symbolic and interprocedural analyses in order to try to alleviate this performance problem. However, in practice it is still significantly slow for complex real codes.
Level 1
Code Instructions
Goals: Find stylistic issues, code formatting issues, duplicated code, and unused code.
Level 2
Code conditions & Decision-making
Goals: Find reaching definitions, liveness analysis, definite assignment analysis, available expression, constant propagation.
Level 3
Symbolic & Interprocedural
Goals: Find dead code, out-of-bound array indices, and buffer overflows.
Parallelware Analyzer goes beyond the state-of-the-art, defining one additional level 4 that enables deep source code analysis as required by performance optimization through vectorization, multi-threaded execution and offloading to accelerator processors.
Level 4
Parallelism
Goals: Detection of reductions, data dependence analysis, data scoping analysis, explicit privatization, memory semantics, abstract dependence analysis across loop boundaries/functions/files.
The architecture of the Parallelware Analyzer’s AI engine comprises three layers. The first layer is Code normalization, which abstracts away different variations of the implementation of a code. The second layer is called Classification of semantic patterns, which interprets the source code in terms of a set of semantic patterns specializing in performance and parallelism. And the third layer Pattern-based abstract reasoning uses the knowledge about semantic patterns to support key use cases of parallel programming in C/C++/Fortran targeting multicore CPUs and GPUs.
Overall, Parallelware Analyzer’s new AI engine is specifically designed for static code analysis to boost the performance of C/C++ and Fortran codes. It is extensible and fast, enabling Appentra to develop new cutting-edge innovative developer tools to improve software performance on low-power multicore processors.
Get started with Parallelware Analyzer
Parallelware Analyzer selected as a SC18 Emerging Technology.
Subscribe to our newsletter and get all of our updates