To get a trial key
fill out the form below
Team License (a basic version)
Enterprise License (an extended version)
* By clicking this button you agree to our Privacy Policy statement

Request our prices
New License
License Renewal
--Select currency--
* By clicking this button you agree to our Privacy Policy statement

Free PVS-Studio license for Microsoft MVP specialists
* By clicking this button you agree to our Privacy Policy statement

To get the licence for your open-source project, please fill out this form
* By clicking this button you agree to our Privacy Policy statement

I am interested to try it on the platforms:
* By clicking this button you agree to our Privacy Policy statement

Message submitted.

Your message has been sent. We will email you at

If you haven't received our response, please do the following:
check your Spam/Junk folder and click the "Not Spam" button for our message.
This way, you won't miss messages from our team in the future.

Our first practical research in the sph…

Our first practical research in the sphere of metrics calculation

Jun 09 2009

Not so long ago we began to think about the question of analyzing program code not only from the viewpoint of presence of 64-bit or OpenMP errors in it but from the viewpoint of its complexity for adaptation for 64-bit and parallel systems as well. And we would like to tell you about our first practical experiments in this sphere.

The reason to think about calculation of metrics was a question asked by one of our clients - how to grossly estimate the complexity of porting a project on a 64-bit system. As this question may be relevant for many of our potential clients, a tool for calculating metrics can provide great help here.

Now we are uniting our two tools Viva64 and VivaMP into a single software product for developers - PVS-Studio. Within the framework of this product it will be natural to implement a new function to prognose the complexity of a software product and also to estimate the time needed for adapting it for parallel or 64-bit systems.

Although there are many various metrics, after reviewing them we did not manage to find the methods to estimate their complexity by the criteria we needed. Perhaps, our search was not thorough enough but may be there are actually no such metrics. That's why we implemented our own calculation metrics which obviously need further improvement and now we can only tell you about intermediate results achieved in the experimental program VivaShowMetrics.

VivaShowMetrics program operates with preprocessed files (*.i) and builds graphs by five metrics at the output:

  • Common complexity - general complexity of a function. For this characteristic is not crucial for us we refused to use classic methods such as, for example, calculation of cyclomatic complexity, for calculating it. We use rather a simple metrics based on the number of branches in the function's body, the number of calls of other functions and the number of arithmetic operations.
  • Function paralleling complexity. Expected complexity of the function's paralleling with the use of OpenMP technology. The rules for calculating this and further metrics are constantly changing and there is no sense in describing them yet.
  • Parallel function's unsafety. Shows how much the function is subject to errors when paralleling it with the use of OpenMP technology. In other words, how easily a programmer can make an error when paralleling this function.
  • Complexity of implementing the function's 64-bit version. Expected complexity of adaptation of the function for a 64-bit system.
  • 64-bit function's unsafety. Shows the probability that this function contains an error from the viewpoint of 64-bit systems.

For convenient examination the collected metrics on each function are sorted in a descending order. As a result, for the library CImg (C++ Template Image Processing Toolkit) you can see rather a typical situation:


Functions which are unsafe and complex from the viewpoint of paralleling and 64-bit compose a small part of the general number of functions. All the rest functions are rather simple and for the most part are an interface for the user's code.

But if you load the file relating to the system of Viva64 analyzer's unit-tests you will see quite a different situation:


There are many functions on which the analyzer must show messages relating to 64-bit errors. Although the functions are small, still they are rather complex and unsafe in every way. It is because of this that the percent of unsafe functions is rather large. And the graph of 64-bit complexity advances greatly the graph of porting complexity. It is explained by that small functions in the code contain a large amount of errors. The functions are unsafe but they are easy to correct.

Popular related articles
Free PVS-Studio for those who develops open source projects

Date: Dec 22 2018

Author: Andrey Karpov

On the New 2019 year's eve, a PVS-Studio team decided to make a nice gift for all contributors of open-source projects hosted on GitHub, GitLab or Bitbucket. They are given free usage of PVS-Studio s…
The way static analyzers fight against false positives, and why they do it

Date: Mar 20 2017

Author: Andrey Karpov

In my previous article I wrote that I don't like the approach of evaluating the efficiency of static analyzers with the help of synthetic tests. In that article, I give the example of a code fragment…
How PVS-Studio Proved to Be More Attentive Than Three and a Half Programmers

Date: Oct 22 2018

Author: Andrey Karpov

Just like other static analyzers, PVS-Studio often produces false positives. What you are about to read is a short story where I'll tell you how PVS-Studio proved, just one more time, to be more atte…
PVS-Studio ROI

Date: Jan 30 2019

Author: Andrey Karpov

Occasionally, we're asked a question, what monetary value the company will receive from using PVS-Studio. We decided to draw up a response in the form of an article and provide tables, which will sho…
Characteristics of PVS-Studio Analyzer by the Example of EFL Core Libraries, 10-15% of False Positives

Date: Jul 31 2017

Author: Andrey Karpov

After I wrote quite a big article about the analysis of the Tizen OS code, I received a large number of questions concerning the percentage of false positives and the density of errors (how many erro…
PVS-Studio for Java

Date: Jan 17 2019

Author: Andrey Karpov

In the seventh version of the PVS-Studio static analyzer, we added support of the Java language. It's time for a brief story of how we've started making support of the Java language, how far we've co…
The Ultimate Question of Programming, Refactoring, and Everything

Date: Apr 14 2016

Author: Andrey Karpov

Yes, you've guessed correctly - the answer is "42". In this article you will find 42 recommendations about coding in C++ that can help a programmer avoid a lot of errors, save time and effort. The au…
The Evil within the Comparison Functions

Date: May 19 2017

Author: Andrey Karpov

Perhaps, readers remember my article titled "Last line effect". It describes a pattern I've once noticed: in most cases programmers make an error in the last line of similar text blocks. Now I want t…
Appreciate Static Code Analysis!

Date: Oct 16 2017

Author: Andrey Karpov

I am really astonished by the capabilities of static code analysis even though I am one of the developers of PVS-Studio analyzer myself. The tool surprised me the other day as it turned out to be sma…
Static analysis as part of the development process in Unreal Engine

Date: Jun 27 2017

Author: Andrey Karpov

Unreal Engine continues to develop as new code is added and previously written code is changed. What is the inevitable consequence of ongoing development in a project? The emergence of new bugs in th…

Comments (0)

Next comments
This website uses cookies and other technology to provide you a more personalized experience. By continuing the view of our web-pages you accept the terms of using these files. If you don't want your personal data to be processed, please, leave this site.
Learn More →