Oracle® Solaris Studio 12.4: Performance Analyzer

Exit Print View

Updated: January 2015

Synchronization Wait Tracing Data

In multithreaded programs, the synchronization of tasks performed by different threads can cause delays in execution of your program. For example, one thread might have to wait for access to data that has been locked by another thread. These events are called synchronization delay events and are collected by tracing calls to the Solaris or pthread thread functions. The process of collecting and recording these events is called synchronization wait tracing. The time spent waiting for the lock is called the wait time .

Events are only recorded if their wait time exceeds a threshold value , which is given in microseconds. A threshold value of 0 means that all synchronization delay events are traced, regardless of wait time. The default threshold is determined by running a calibration test, in which calls are made to the threads library without any synchronization delay. The threshold is the average time for these calls multiplied by an arbitrary factor (currently 6). This procedure prevents the recording of events for which the wait times are due only to the call itself and not to a real delay. As a result, the amount of data is greatly reduced, but the count of synchronization events can be significantly underestimated.

For Java programs, synchronization tracing covers Java method calls in the profiled program but does not trace any internal synchronization calls within the JVM.

Synchronization wait tracing data is converted into the metrics in the following table.

Table 2-2  Synchronization Wait Tracing Metrics
Synchronization delay event count .
The number of calls to a synchronization routine where the wait time exceeded the prescribed threshold.
Synchronization wait time .
Total of wait times that exceeded the prescribed threshold.

From this information you can determine whether functions or load objects are either frequently blocked or experience unusually long wait times when they do make a call to a synchronization routine. High synchronization wait times indicate contention among threads. You can reduce the contention by redesigning your algorithms, particularly restructuring your locks so that they cover only the data for each thread that needs to be locked.