Intel® Thread Checker for Linux* - Product Limitations

This release does not support Unicode file names.

Intel® Thread Checker for Linux* does not support binary instrumentation on Intel® Itanium platforms.

Intel® Thread Checker may face some incompatibility issues with lguide library provided by older version of Intel® Math Kernel library. Please upgrade to the latest version of Intel® Math Kernel library for Linux* (8.0 and higher) if you encounter error message similar to "undefined references to _kmpc_global_thread_num".

Source instrumentation on Intel® Itanium® platforms requires the -ltcdata switch for Intel® compiler.

If you are using counted FLEXlm* license files during the installation of the client applications, please make sure that either the FLEXlm* server is not running or the FLEXlm* server is running with the complete license files that are used during the installation process.

The binary instrumentation technology used by Intel® Thread Checker for Linux* may cause some applications to change behavior or terminate abnormally. If this happens,try lowering the instrumentation levels of the problematic modules.

Intel Thread Checker for Linux* does not detect threading errors for threads and synchronization objects shared across processes (executables).

Intel Thread Checker for Linux* cannot analyze processes that are already running. You must either specify the executable as the application to launch, or specify it as a module of interest.

Intel Thread Checker for Linux* supports analysis of native binaries and does not support intermediate executable representations intended for managed runtime environments.

If an application has data races on a global variable, the definition information of the variable is not be available.

Software that defines functions with names that match system API names such as fread() or pthread_create() may have link failures when built with source instrumentation using "-tcheck". Such software may crash when run with Intel Thread Checker. To avoid this problem, ensure that your software uses function names that do not match system API names to avoid these issues.

When using source instrumentation with functions that contain inline assembly, Thread Checker may generate invalid diagnostics if data is collected outside of the Intel Thread Checker for Linux* Command Line or remote Linux Collector. To avoid this, compile without "-tcheck" option and run your application in the Intel Thread Checker for Linux* Command Line or Remote Linux Collector.

Linux* Analysis

To use source instrumentation on Linux*, you must set up the environment before compiling with "-tcheck" or starting the ittserver, for example:

  • Linux* 32-bit:
    /opt/intel/itt/tcheck/bin/32/tcheckvars.sh
    or
    source /opt/intel/itt/tcheck/bin/32/tcheckvars.csh


  • Linux* 64-bit on Intel® EM64T processors:
    /opt/intel/itt/tcheck/bin/32e/tcheckvars.sh
    or
    source /opt/intel/itt/tcheck/bin/32e/tcheckvars.csh


  • Linux* 64-bit on Itanium® processors:
    /opt/intel/itt/tcheck/bin/64/tcheckvars.sh
    or
    source /opt/intel/itt/tcheck/bin/64/tcheckvars.csh

This release does not support the following types of Linux* binaries:

  • Linux applications statically linked with C/C++ runtime library or POSIX* thread library.
  • The Linux* kernel and any kernel modules.
  • The Linux* dynamic linker/loader (/lib/ld.linux.so.*, /lib/ld.*.so).

Asynchronous signal handling is not fully supported in this release. Programs that use asynchronous signals may stall when analyzed with Intel Thread Checker.

When an instrumented application calls the exec system function, the whole image context is replaced with the new image. If the application calls exec with the name of the instrumented image, then the instrumented image is used. In the other cases, the original (non-instrumented) image is called, and no results will be generated from this point in the run.

Intel® Thread Checker for Linux* does not support setuid images. The setuid mechanism is used to give a user process the effective user ID of another user, usually root. You can use Intel® Thread Checker for Linux* and run the setuid executable only if you are logged in as the same user as the owner of the setuid executable.

The application to analyze cannot be a command-line application that expects interactive user input.

If pthread_exit() is called from the main thread, and if actual deadlock and stall detection or real time diagnostic display is turned on and forceful program termination upon deadlock or program exit is turned off, the program may hang under Intel Thread Checker analysis. If this happens, please turn off deadlock and stall detection and real time diagnostic display or turn on forceful program termination upon deadlock or program exit.

Source and Binary instrumentation may dramatically increase the use of stack space. On Linux* you can use the limit or ulimit commands to specify the stack space used by applications. You may need to increase the stack space to complete the data collection. However, be careful with an unlimited stack space specification. This can result in insufficient space to create the pthread stacks which can cause the data collection to fail.

For more complete information about compiler optimizations, see our Optimization Notice.