Performance Management Guide

SMP Performance Issues

To effectively use an SMP, take the following into account when you are attempting to enhance performance:

Workload Concurrency

The primary performance issue that is unique to SMP systems is workload concurrency, which can be expressed as, "Now that we have n processors, how do we keep them all usefully employed"? If only one processor in a four-way multiprocessor system is doing useful work at any given time, it is no better than a uniprocessor. It could possibly be worse, because of the extra code to avoid interprocessor interference.

Workload concurrency is the complement of serialization. To the extent that the system software or the application workload (or the interaction of the two) require serialization, workload concurrency suffers.

Workload concurrency may also be decreased, more desirably, by increased processor affinity. The improved cache efficiency gained from processor affinity may result in quicker completion of the program. Workload concurrency is reduced (unless there are more dispatchable threads available), but response time is improved.

A component of workload concurrency, process concurrency, is the degree to which a multithreaded process has multiple dispatchable threads at all times.

Throughput

The throughput of an SMP system is mainly dependent on:

• A consistently high level of workload concurrency. More dispatchable threads than processors at certain times cannot compensate for idle processors at other times.
• The amount of lock contention.
• The degree of processor affinity.

Response Time

The response time of a particular program in an SMP system is dependent on:

• The process-concurrency level of the program. If the program consistently has two or more dispatchable threads, its response time will probably improve in an SMP environment. If the program consists of a single thread, its response time will be, at best, comparable to that in a uniprocessor of the same speed.
• The amount of lock contention of other instances of the program or with other programs that use the same locks.
• The degree of processor affinity of the program. If each dispatch of the program is to a different processor that has none of the program's cache lines, the program may run more slowly than in a comparable uniprocessor.