IBM Power7 Optimization And Tuning Manual page 91

The most significant issue is typically the porting effort (for existing applications), as changing
between ILP32 and LP64 normally requires a port. Large memory addressability and
scalability are normally the deciding factor when you chose an application execution model.
For more information about this topic, see 4.4, "Related publications" on page 94.
Affinity APIs
Most applications must be bound to logical processors to get a performance benefit from
memory affinity to prevent the AIX dispatcher from moving the application to processor cores
in different Multi-chip Modules (MCMs) while the application runs.
The most likely way to obtain a benefit from memory affinity is to limit the application to
running only on the processor cores that are contained in a single MCM. You can accomplish
this task by running the bindprocessor command and the bindprocessor() function. It can
also be done with the resource set affinity commands (rset) and service applications. Often,
affinity is provided as an administrator option that can be optionally enabled on large systems.
When the application requires more processor cores than contained in a single MCM, the
performance benefit through memory affinity depends on the memory allocation and access
patterns of the various threads in the application. Applications with threads that individually
allocate and reference unique data areas might see improved performance.
The AIX Active System Optimizer (ASO) facility is capable of autonomously establishing
enhanced affinity (see 4.2, "AIX Active System Optimizer and Dynamic System Optimizer" on
page 84). This situation is in contrast to the manual usage of the affinity APIs documented in
this section.
Processor affinity (bindprocessor)
Processor affinity is the probability of dispatching of a thread to the logical processor that was
previously running it. If a thread is interrupted and later redispatched to the same logical
processor, the processor's cache might still contain lines that belong to the thread. If the
thread is dispatched to a different logical processor, it probably experiences a series of cache
misses until its cache working set is retrieved from RAM or the other logical processor's
cache. If a dispatchable thread must wait until the logical processor that it was previously
running on is available, the thread might experience an even longer delay.
The highest possible degree of processor affinity is to bind a thread to a specific logical
processor. Binding means that the thread is dispatched to that logical processor only,
regardless of the availability of other logical processors.
The bindprocessor command and the bindprocessor() subroutine bind the thread (or
threads) of a specified process to a particular logical processor. Explicit binding is inherited
through fork() and exec() system calls. The bindprocessor command requires the process
identifier of the process whose threads are to be bound or unbound, and the bind CPU
identifier of the logical processor to be used.
While CPU binding is useful for CPU-intensive applications, it can sometimes be counter
productive for I/O-intensive applications.
RSETS
Every process and kernel thread can have an RSET attached to it. The CPUs on which a
thread can be dispatched are controlled by a hierarchy of resource sets. RSETs are
mandatory bindings and are honored by the AIX kernel always. Also, RSETs can affect
Dynamic Reconfiguration (DR) activities.
75
Chapter 4. AIX