» Sign in
  

Description

Visual Threads is a tool that lets you debug and analyze multithreaded applications. It can be used to automatically diagnose common problems associated with multithreading, including deadlock, protection of shared data (Tru64 UNIX only), and thread usage errors. It can also be used to monitor the thread-related performance of the application, helping you to identify bottlenecks or locking granularity problems. It is a unique debugging tool because it can be used to identify problem areas even if an application does not show any specific problem symptoms.
  HP Visual Threads  
»  Visual Threads home
»  Latest news
Overview
»  Rules and Templates
»  Downloads
»  Documentation
»  Technical information
»  FAQ
»  Related links
»  Technical support

Environments

  • On Tru64 UNIX™, Visual Threads is licensed as part of the Developers Toolkit. (The latest released versions of the toolkit components are provided by the Developer's Toolkit Supplement.)

  • On OpenVMS™, Visual Threads shipped with versions beginning with V7.3. For OpenVMS V7.2-1/V7.2.2 systems, and also for newer versions of Visual Threads, the product is available as a free download; Alpha systems only. 

  • On HP-UX Itanium™, Visual Threads is available as a free beta kit.

Functions

Visual Threads provides the following:

  • Event collection: Collects detailed information about the significant thread state changes that occur during the running of a multithreaded application.

  • Event display: At any time, you can view the dynamic display of events as they occur, with options to filter for specific types of events.

  • Automatic rule-based analysis: Detects violation conditions by evaluating the events against a set of enabled rules. Several predefined rules look for deadlock conditions, data protection errors (Tru64 UNIX only), and programming errors.

  • Rule customization: Lets you use templates to define your own rules to specify criteria for violation conditions. In particular, you can specify rules to monitor or identify performance problems.

  • Customized actions: Suspends execution of the application when it detects violation conditions. You can choose from several options at this point, including invoking the debugger in the appropriate context for the application.

  • Playback: Records events to a trace file so you can play back and analyze them later. This is especially useful if you want to analyze a trace file iteratively, perhaps using different rules each time as you discover more information.

  • Statistics: Provides easy access to object-level statistics and current state information, including use of resources (for example, the mutexes held by a particular thread). You can use this information to look for performance problems and to fine tune the application.

  • Performance analysis: Automatic analysis of lock contention and lock granularity, statistical hot spots, and processor utilization.

  • Profiling: Lock activity is profiled for each lock-related statistic, such as the number of locks and number of contended locks. Graphs are displayed showing the program location(s) for each type of lock activity statistic.

  • Visualization: Thread transition graphs provide a detailed view of each change in program state, while thread snapshots give historical context for thread states. Graphs for each object (threads, mutexes, condition variables, Read/Write locks) are provided for each collected statistic. CPU utilization graphs show the CPU percentage used by each thread. Visual Threads also graphically and continuously displays the state of the program threads and the frequency of thread related events.

For example, the following Visual Threads Control Panel shows a portion of a running program (Java) on a Tru64 UNIX system, which program is generating approximately 2000 thread events per second. One thread is running, one is ready to run, four threads are blocked, and one thread has terminated. The yellow triangular icons indicate that more information about thread related warning conditions is available.

» Enlarged view

  • Data locality: On Tru64 AlphaServer GS Series systems, Visual Threads gives you detailed information about the placement of threads and data across the resource affinity domains (RADs) of your Non-Uniform Memory Access (NUMA) system, including the Home RAD for threads and synchronization objects. It can also provide information about accesses to data pages from each RAD and page access profiling.

Prerequisites for applications

There are none. No source changes are required, because Visual Threads works with existing executables. An application does not have to be recompiled or relinked, though use of a debugging compilation option is recommended for more effective symbolization.

On Tru64 UNIX, some applications need to be instrumented if certain Visual Threads rules are in effect. Visual Threads automatically instruments these applications using Atom. Then, analysis is performed on the instrumented application.

Applications supported

Visual Threads can be used with any application that uses POSIX threads (Pthreads). There is specific support to make it easier to use with C++ and Java applications. On Tru64 UNIX, note that the rules requiring Atom instrumentation cannot be used with Java applications. And on HP-UX systems, support for Java applications is limited.

Rules and Templates

Visual Threads provides a set of built-in rules that you can use to automatically validate an application's use of threads. Every rule is associated with a particular analysis event, which is triggered when a rule detects a violation condition. When an analysis event is triggered, Visual Threads responds with a rule action (such as stopping the application or ignoring the violation) and provides data to help you analyze and debug the application.

Using templates, you can also define additional rules customized for your application. In particular, certain of the template rules can be used to define criteria to measure thread performance. For example, you can assert that the number of waiting threads for a lock object cannot exceed a certain number. Once you define a rule of this type, then if the number is ever exceeded, Visual Threads informs you that this is a violation of the rule, and allows you to take various actions at that point to diagnose the problem.

For more information about all the rules and templates see Visual Threads Rules and Templates.



Manage My AllianceOne Membership

 
 » Sign in
 » Join AllianceOne
 » Contact us