gcov | code coverage for c | Command Line Interface library

I needed to add LIBS="-lz -lzstd -llzma". The full configuration command looks like this:

The problem was there were other /bin/ directories that had older versions of gcc and openmpi. When updating, the new files from /lib/ directories needed to be trasnfered to the /Cellar/ directories. The problem is fixed when first uninstalling all old macports and compilers with incorrect files and/or paths as sudo port -fp uninstall installed, and brew uninstall openmpi, and brew uninstall gcc. Then reinstall new homebrew compilers brew install gcc, brew install openmpi. This gives the correct paths with configured files when submitting a make file.

It's not a GCC 8 problem (you should undo the GCC 8 installation changes).

The error message "gcc: internal compiler error: Killed (program cc1plus)" indicates that the compiler crashed. Most likely, this is because it ran out of memory (RAM).

If the build was using multiple cores to compile, then compiling with less concurrency should help. Try bazel build //... -j 1, perhaps. If that helps, you could put that into a dotfile via https://docs.bazel.build/versions/master/guide.html#bazelrc-the-bazel-configuration-file so that jobs are always limited when building on that machine.

However, if only one file is being compiled at a time and you still run of memory, then you'll probably need to increase the memory allocation of the virtual machine.

The source for gcov 7.5.0 is here.

The snippet below shows where headers are printed. File2 happens to be in a directory with multiple source files. Because of that the graph, data, and runs headers are being omitted.

I believe you forgot to add appropriate flags

Updating gcovr to be inline with gcc is a little bit tricky - all the steps I mentioned above are valid and should infact work - so I will leave this question here since I think it has some value and I can't yet find this method anywhere else.

The final part of my puzzle was that I needed to use a local mirror so by running:

Did you try sonar-cxx plug-in from SonarOpenCommunity. This plugin adds C++ support to SonarQube. It's free plug-in and availble with LGPL-3.0 License.

If you're talking specifically about the gcov tools, the branch coverage is really counting the points at which the end of each basic block is reached. See Understanding branches in gcov files.

Condition coverage is something different. See Is it possible to check condition coverage with gcov? (The answer is no, it's not, at least not with just gcov.) As Marc Gilsse's comment notes, you can use gcov -a to count executions through each basic block, and use that as a reasonable approximation—but it's not the same thing.

C++'s exceptions make dealing with branch coverage messy; see LCOV/GCOV branch coverage with C++ producing branches all over the place. This means you won't necessarily be able to cover all branches in the first place.

See also, e.g., Understanding blocks in gcov files.

Short answer: Cache invalidation is hard.

In a RUN section of a Dockerfile, any command can be run. In general, docker (when using local caching) or Kaniko now have do decide, if this step can be cached or not. This is usually determined by checking, if the output is deterministic - in other words: if the same command is run again, does it produce the same file changes (relative to the last image) than before?

Now, this simplistic view is not enough to determine a cacheable command, because any command can have side-effects that do not affect the local filesystem - for example, network traffic. If you run a curl -XPOST https://notify.example.com/build/XYZ to post a successful or failed build to some notification API, this should not be cached. Maybe your command is generating a random password for an admin-user and saves that to an external database - this step also should never be cached.

On the other hand, a completely reproducible npm run build could still result in two different bundled packages due to the way, that minifiers and bundlers work - e.g. where minified and uglified builds have different short variable names. Although the resulting builds are semantically the same, they are not on a byte-level - so although this step could be cached, docker or kaniko have no way of identifying that.

Distinguishing between cacheable and non-cacheable behavior is basically impossible and therefore you'll encounter problematic behavior in form of false-positives or false-negatives in caching again and again.

When I consult clients in building pipelines, I usually split Dockerfiles up into stages or put the cache-miss-or-hit-logic into a script, if docker decides wrong for a certain step.

When you split Dockerfiles, you have a base-image (which contains all dependencies and other preparation steps) and split off the custom-cacheable part into its own Dockerfile - the latter then references the former base-image. This usually means, that you have to have some form of templating in place (e.g. by having a FROM ${BASE_IMAGE} at the start, which then is rendered via envsubst or a more complex system like helm).

If that is not suitable for your usecase, you can choose to implement the logic yourself in a script. To find out, which files change, you can use git diff --name-only HEAD HEAD~1. By combining this with some more logic, you can customize your script behavior to only perform some logic if a certain set of files changed: