VMS Help System Services, $SET IMPLICIT AFFINITY (Alpha Only)  *Conan The Librarian (sorry for the slow response - running on an old VAX)

    On Alpha systems, controls or retrieves the activation state
    for the implicit affinity system capability of a specific kernel
    thread or of the global process default.

    This service accepts 64-bit addresses.

    Format

      SYS$SET_IMPLICIT_AFFINITY  [pidadr] [,prcnam] [,state]

                                 [,cpu_id] [,prev_mask]

    C Prototype

      int sys$set_implicit_affinity  (unsigned int *pidadr, void

                                     *prcnam, struct _generic_64

                                     *state, int cpu_id, struct

                                     _generic_64 *prev_mask);

1 - Arguments

 pidadr

    OpenVMS usage:process_id
    type:         longword (unsigned)
    access:       read only
    mechanism:    by 32- or 64-bit reference
    Process identification (PID) of a kernel thread whose implicit
    affinity is to be modified or returned. The pidadr argument is
    the 32- or 64-bit address of a longword that contains the PID.

    Process selection is made through a combination of the pidadr and
    prcnam arguments. If neither are specified or if both have a zero
    value, the service operations are made to the user capability
    mask of the current kernel thread of the current calling process.
    The pidadr argument takes precedence over the prcnam argument
    where both are supplied in the service call.

    If the bit constant CAP$M_IMPLICIT_DEFAULT_ONLY is specified in
    the state argument, then the implicit affinity state portion of
    the default capability mask is modified or returned instead.

 prcnam

    OpenVMS usage:process_name
    type:         character-coded text string
    access:       read only
    mechanism:    by 32- or 64-bit descriptor-fixed-length string
                  descriptor
    Process name of the process whose implicit affinity capability
    state is to be modified or returned. The prcnam argument is the
    32- or 64-bit address of a character string descriptor pointing
    to the process name string. A process can be identified with a
    1- to 15-character string. The service operations are made to
    the user capability mask of the initial thread of the specified
    process.

    If pidadr and prcnam are both specified, then pidadr is modified
    or returned and prcnam is ignored. If neither argument is
    specified, then the context of the current kernel thread of the
    calling process is modified or returned.

 state

    OpenVMS usage:mask_quadword
    type:         quadword (unsigned)
    access:       read only
    mechanism:    by 32- or 64-bit reference
    State options that can be selected for the affected thread's
    implicit affinity. The state argument is a pointer to a quadword
    bit vector wherein a bit corresponds to a requested state for
    the implicit affinity feature. Only the bits specified below are
    used; the remainder of the quadword bits are reserved.

    Each option (bit) has a symbolic name, defined in the $CAPDEF
    macro. The state argument is constructed by performing a logical
    OR operation using the symbolic names of each desired option.

    The following table describes the symbolic name of each option:

    Symbolic Name          Description

    CAP$M_IMPLICIT_        Indicates the specified operations are to
    DEFAULT_ONLY           be performed on the global cell instead
                           of on a specific kernel thread. This bit
                           supersedes any individual kernel thread
                           specified in pidadr or prcnam. Specifying
                           this bit constant applies the implicit
                           affinity operations to all newly created
                           processes.

    CAP$M_IMPLICIT_        Indicates that the implicit affinity
    AFFINITY_SET           capability bit is to be set for the
                           specified kernel thread. This is mutually
                           exclusive with CAP$M_IMPLICIT_AFFINITY_
                           CLEAR.

    CAP$M_IMPLICIT_        Indicates that the implicit affinity
    AFFINITY_CLEAR         capability bit is to be cleared for the
                           specified kernel thread. This is mutually
                           exclusive with CAP$M_IMPLICIT_AFFINITY_
                           SET.

 cpu_id

    OpenVMS usage:longword
    type:         longword (unsigned)
    access:       read only
    mechanism:    by value
    Identifier of the CPU requested as the first CPU on which this
    kernel thread is to execute. The cpu_id is a longword containing
    this number, which is in the supported range of individual CPUs
    from 0 to SYI$_MAX_CPUS -1.

    If no explicit CPU is needed, specifying a value of -1 in
    this argument indicates the system is to select the initial
    association based on system dynamics and load balancing.

    Note that, regardless of what explicit CPU is supplied to this
    argument, it will be taken only as a suggestion. This service
    will attempt to make the requested association, but it will be
    superseded by another CPU if the system dynamics are adversely
    affected by the operation.

 prev_mask

    OpenVMS usage:mask_quadword
    type:         quadword (unsigned)
    access:       write only
    mechanism:    by 32- or 64-bit reference
    Previous implicit affinity state mask for the specified kernel
    thread before execution of this call to $SET_IMPLICIT_AFFINITY.
    The prev_mask argument is the 32- or 64-bit address of a quadword
    into which $SET_IMPLICIT_AFFINITY writes a bit mask specifying
    the implicit affinity state.

    The current state of the kernel thread's current implicit
    affinity feature can be determined by testing the returned
    mask with the symbolic bit definitions described for the state
    argument. These bit definitions are found in the $CAPDEF macro.