We are thrilled to announce the official launch of Codee 1.0, the first static code analyzer specializing in performance. During the last 2 years, over 200 early adopters have helped us shape Codee thanks to their invaluable feedback through the Early Access Program. Codee as an innovation company provides a revolutionary approach: Codee, the first […]
performance
Matching the performance of parallel HACCmk with Parallelware Analyzer
Executive Summary Scientific simulations on high performance computing systems represent the type of problems where speed is of utmost importance. Even though those systems are fast, large simulations can take days or even weeks to execute. A way to make simulations faster is parallelization – distributing the task at hand to several CPU cores. Our […]
Flexibility and Performance: turbocharging loop unswitching
In the previous post we talked about loop unswitching: a technique that the compilers use to make loops faster. Loop unswitching consists of detecting conditional statements whose condition never changes during the execution of the loop (loop invariant conditions) and then moving the condition outside of the loop. Loop unswitching opens the door for other […]
Flexibility and performance: introduction to loop unswitching
Flexibility is very important in the development of software. A great deal of research and education is invested into creating flexible software. However, flexibility and performance don’t often come hand in hand, as most developers have already witnessed sometime in their careers. One of the ways to achieve flexibility is to parametrize the behavior of […]
Many ways to speed up your program
There are many approaches to make your program run faster. Some approaches are based on using more efficient libraries, others rely on using the standard library and the language in an efficient manner. Other approaches include using more efficient algorithms. But sometimes, even after we’ve applied all the possible optimizations, the code performance is not […]
Trade a bit of precision for performance on hotspots with compiler vectorization directives
Most of the applications are fine when compiled with the -ffast-math compiler flag, which makes floating-point computations faster at the expense of some precision loss. However, in the scientific domain, floating-point precision is important so most of the time those codebases are compiled without this option. Still, the question of performance of such code remains […]
