One of our customers has a mathematical simulation program where precision matters. We were given the code for evaluation and asked to make it run faster. They have a strict requirement that the source code is compiled without any optimization flags that can influence precision. Most compilers offer a fast-math compiler flag that significantly improves […]
Technical
Is your algorithm running at peak performance? The roofline model
There are worlds where performance matters. For example HPC world: faster software means less wait time for the scientists. Embedded world: faster software means we can use cheaper silicon to build our product. Game world: faster software means that our game will run on slower CPUs, thus making our game more interesting to people with […]
Case Study: How we made the Canny edge detector run faster? (part 2)
In the previous post we talked about the performance improvement we obtained for the Canny edge detection algorithm. Most of the changes we did there were focused on hot loops: making memory accesses sequential and making the loops longer, which in turn allowed the compiler to autovectorize them. This made our program run significantly faster […]
A touch of parallelism: example of NPB CG Benchmark
Our ultimate goal at Appentra is to create a software suite that will help users achieve the peak performance of their software. One of the ways to do it is with a touch of parallelism. This post will talk about the NPB CG benchmark, a popular benchmark for comparing supercomputers, developed by NASA. We will […]
Case Study: How we made Canny edge detector algorithm run faster? (part 1)
Canny edge detector algorithm is a famous algorithm in image processing. One of our customers was inquiring about the performance of that algorithm, so our performance engineers took a look. As always when dealing with unfamiliar codebases, we didn’t know what to expect. Some algorithms have a lot of room for performance improvements, others don’t. […]
Interprocedural analysis across source code files with Parallelware Analyzer
Programs are rarely built from a single source code file. Normally, code is organized into several source files, reaching hundreds or even thousands of files for large programs. Static code analysis tools work by analyzing the source code files. When a function defined in a source file calls another function defined in a different source […]
Using CMake’s compilation database with Parallelware Analyzer
When building a program, seldom do we only invoke the compiler passing a source file and an output binary name. In most cases, we must supply several compiler flags such as include paths or macro definitions. A program is usually built by compiling different source files where each may require different compiler flags. One of […]
Parallelware Analyzer NPB Quickstart
Index What is Parallelware Analyzer?– Where to start?– Useful options common to all toolsQuickstart with NAS Parallel BenchmarksUsing a configuration file Early Access Program is now open! Enter the program to have access to all versions of Parallelware Analyzer and support until the official release. What is Parallelware Analyzer? Parallelware Analyzer is a suite of […]
Customizing Parallelware Trainer through environment variables
Starting with version 1.4.0, Parallelware Trainer can be customized using environment variables. This is particularly helpful in deployments using a multi-user license or when certain development packages are installed in non-standard locations (e.g. MPI headers being located in /opt/mpi/include instead of in /usr/include/mpi). Customizing license file location When looking for a license file, Parallelware Trainer […]
Defects and recommendations for parallelism
Implementing parallel software is hard. On top of all the kinds of bugs that may be present in sequential code, parallel code can also suffer from race conditions. A race condition exists when several threads access the same data at the same time and at least one of them writes to it. Opening the door […]