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

Detects Both Memory and Threading Errors

Memory errors like leaks, corruption, and illegal accesses can be very hard to find without a tool. Threading errors like races and deadlocks can be even harder because they are normally non-deterministic and difficult to reproduce. Intel® Inspector finds errors and makes them deterministic and debuggable. Check out the complete list of threading and memory errors:

Dynamic Instrumentation: Simple, Reliable, Accurate

Unlike other memory and threading analysis tools, Intel Inspector never requires any special recompiles for analysis. Just use your normal debug or production build. (Include symbols so we can map to the source.) This not only makes your workflow faster and easier, it increases reliability and accuracy. Competitive static, compilation-based instrumentation techniques struggle with dynamically generated or linked code. Intel Inspector inspects all code including third-party libraries where the source is not available.

Check and Debug C, C++, and Fortran Applications

Do you have legacy code in Fortran? Are you using libraries without the source? No problem, it all works. Dynamic instrumentation enables inspection of all code including third-party libraries where the source is not available.

Choose Your Level: Go Fast or Be Thorough

The first level of analysis has little overhead. Use it during development because it is fast. The second level (shown below) takes more time and detects more issues. It is often used before checking in a new feature. The third level is great for regression testing and finding bugs.

Debugger Breakpoints Simplify Diagnosis

Debugger breakpoints make it easier to diagnose difficult errors by breaking into the debugger just before the error occurs. Examine variables and look at other threads to diagnose the problem. The Microsoft Visual Studio* debugger, GNU Debugger (GDB)*, and Intel® Debugger are supported. Just select the error and choose Debug This Problem from the menu.

screenshot of selecting Debug This Problem in the interface

Incrementally Diagnose Memory Growth

Intel Inspector graphically shows memory growth as the application is running. It then lets you specify a cause for the memory growth and provides call stack and code snippet information to help eliminate it.

screenshot of memory used in the analysis tool and target application

Analyze Heap Growth Incremental Leak Report

Puzzled about what is causing your memory use to increase as your app continues to run? Heap growth analysis helps you diagnose the cause. Get an incremental heap growth report of allocations not de-allocated since the last baseline. You can also get an incremental report of leaks since the last baseline.

Pause/Resume Speeds Up Analysis

Speed up analysis by limiting its scope. Turn on analysis only during the execution of the suspected problem. Instrumentation overhead is reduced to speed through long, irrelevant sections of code. Used carefully, this can be very powerful in situations where long run times are required to reach the error.

Suppress False Errors, Share with the Team

False errors are easily added to a suppression list so you don’t need to investigate them next time. Multiple lists are supported and can be shared with other project members. Create your own private suppressions to block errors that are not in your code. Suppressing an entire module can also reduce collection time.

Team Collaboration

Each error reported contains state information (New, Confirmed, Fixed, Not Fixed, Regression, Not a Problem, Deferred) to help you sort and prioritize errors.

screenshot of states to change

Filters Manage the Error List

Just want to see the errors from your source file? Click and only those errors are shown. Working through the new errors and only want to see the highest severity? Just click. Filters are available for many categories including severity, problem type, state, module, etc. They eliminate the noise and let you focus on what is most important.

Inspect Software for Intel® Xeon Phi™ Processors

Intel Inspector runs natively on self-booting Intel® Xeon Phi™ processors. Inspecting your app while running it on a multicore processor will detect memory and threading errors.

Limit Analysis Range

Eliminate false errors and speed up analysis by using an API to mark memory that should not be analyzed (for example, it contains a synchronization data structure).

Fewer False Positives, Better Error Messages

Intel Inspector understands the semantics of the Intel® Threading Building Blocks (Intel® TBB) and OpenMP* parallel programming models. This saves time.

  • It reports fewer false positives than competitive products.
  • Errors are described using familiar terms from the source, not with cryptic internal runtime labels.

Same User Interface for Multiple Operating Systems

Are you developing for both Windows* and Linux*? Wouldn’t it be easier to use the same analysis tools for both? Intel Inspector has the same user interface on both operating systems. On Windows, it can be used as a stand-alone product or integrated with Microsoft Visual Studio*.

Analyze MPI Applications for Memory and Threading Errors

Intel Inspector can find both memory and threading errors on MPI applications. Performing an initial analysis on a single shared memory system will identify many errors. And additional analysis can also be run on a cluster. Results are sorted by rank.

Pointer Checker: Find Difficult-to-Diagnose, Out-of-Bounds Accesses

Pointer Checker is a compiler-based diagnostic that traps memory accesses beyond allocated addresses. Find dangling pointers, buffer overflows, etc. Speed up diagnosis by breaking into the debugger when the exception occurs. Just compile using an Intel® compiler with Pointer Checker enabled (/Qcheck-pointers on Windows or –check-pointers on Linux), and then run your code. It identifies and reports out-of-bounds memory accesses.

Windows Pointer Checker:

Linux Pointer Checker: