Intel® Inspector

Memory and Thread Debugger

  • Save money: Locate root cause errors early―before you release
  • Save time: Quickly debug intermittent races and deadlocks
  • Save your data: Find persistence errors when using Intel® Optane™ DC Persistent Memory
  • Take advantage of Priority Support―connect privately with Intel engineers for technical questions

Frequently Asked Questions

Do I have to recompile and rebuild my programs to use Intel® Inspector?
No. Intel® Inspector’s memory and thread checking tools instrument and analyze your program binaries dynamically. You don’t need to recompile or rebuild your programs. We recommend use of debug binaries or release binaries with debug information, so that error reports can be attributed to source code locations.
Will Intel Inspector find all memory and threading errors in my application?
Though it is likely that Intel Inspector can find any memory or threading errors present in the code paths exercised in applications when run at the highest levels of analysis, there is no guarantee that Intel Inspector will find all memory and threading errors in your program.
What is the interactive debugging feature?
Intel Inspector’s interactive debugging allows you to use a standard debugger to investigate memory or threading problems found by the tool. It supports the Microsoft Visual Studio* debugger on Windows* and the Intel and GNU debuggers on Linux*.
Is thread checking capable of finding potential errors in my application?
It depends on the scope of the potential errors. Thread checking analysis is dynamic and only finds errors in the code that is executed. It does not detect errors in any code that is not executed. In the executed code, thread checking is able to find potential errors like data races, cross-thread stack accesses, and potential deadlocks. This is why thread checking sometimes reports errors in your program, even if your program produces correct output.
Will thread checking find logical errors such as atomicity violations in my program (e.g., two memory accesses that should be in the same critical section are in two different critical sections)?
No, thread checking in the current product does not detect logical errors such as atomicity violations.
For parallel programs, does threading (or memory) analysis run in parallel? In other words, does analysis make use of available multicore hardware?
Yes. Both memory checking and threading checking perform analysis on available cores or hardware threads utilized by the target parallel program. The analysis overhead scales nicely and is similar to the scaling factor seen by the target application.
Do I have to run thread checking on a multicore machine? I use a single processor and single-core machine for my development. Can I still use thread checking to find bugs in my code?

Intel Inspector is capable of detecting threading errors even on single-core machines. You don’t have to run thread checking on a multicore machine as long as your program uses multiple threads. If your program creates threads explicitly using Windows* or POSIX* threading APIs, you don’t have issues with creating multiple threads on a single-processor and single-core machine. If your program uses Intel® Threading Building Blocks (Intel® TBB), OpenMP* pragmas, or another task or threading model that normally creates threads based on the number of available cores on the machine, you need to force the underlying threading model to create multiple threads.

Of course, you will get better performance if you have a multicore machine.

I am using third-party code in my development. Can Intel Inspector exclude the third-party binaries and focus on my code?

Yes, you can specify the modules to be excluded in the GUI or command line for thread checking and memory checking.

However, this is not recommended for memory checking. Uninitialized memory or bad pointers can be passed into third-party libraries, and their use may not be detected if the third-party libraries were excluded. In cases like these, the problem is not in the third-party library.

I am developing a plug-in module. How can I use Intel Inspector to analyze it?

To analyze a plug-in module, you need to run the application that loads and executes the plug-in module under Intel Inspector. Use the module include or exclude options to have Intel Inspector only analyze the plug-in module.

I have my own synchronization or memory management APIs. Can I still use Intel Inspector?

Without additional annotations, Intel Inspector may report false positives when analyzing applications containing custom memory management API or custom synchronization primitives.

Intel Inspector provides a set of APIs to allow you to annotate your source code to notify the analysis of your synchronization and memory management APIs.

Is memory checking capable of finding potential errors in my program?
No. Memory checking only detects errors that occur during the analysis run of your program.