Glossary of performance terminology

Glossary of performance terminology

This section contains definitions of the key terms used throughout this book in discussing the performance of computer systems.

AIO -- See asynchronous I/O.

asymmetric multiprocessing -- A multiprocessor system is asymmetric when processors are not equally able to perform all tasks. For example, only the base processor is able to control I/O. Most machines acknowledged to be symmetric may still have some asymmetric features present such as only being able to boot using the base processor.

asynchronous I/O -- Provides non-blocking I/O access through a raw device interface.

bandwidth -- The maximum I/O throughput of a system.

base processor -- The first CPU in a multiprocessor system. The system normally boots using this CPU. Also called the default processor, it cannot be deactivated.

bdflush -- The system name for the buffer flushing daemon.

benchmark -- Software run on a computer system to measure its performance under specific operating conditions.

block device interface -- Provides access to block-structured peripheral devices (such as hard disks) which allow data to be read and written in fixed-sized blocks.

blocking I/O -- Forces a process to wait for the I/O operation to complete. Also known as synchronous I/O.

bottleneck -- Occurs when demand for a particular resource is beyond the capacity of that resource and this adversely affects other resources. For example, a system has a disk bottleneck if it is unable to use all of its CPU power because processes are blocked waiting for disk access.

bss -- Another name for data which was not initialized when a program was compiled. The name is an acronym for block started by symbol.

buffer -- A temporary data storage area used to allow for the different capabilities (speed, addressing limits, or transfer size) of two communicating computer subsystems.

buffer cache -- Stores the most-recently accessed blocks on block devices. This avoids having to re-read the blocks from the physical device.

buffer flushing daemon -- Writes the contents of delayed-write buffer buffers from the buffer cache to disk.

cache memory -- High-speed, low-access time memory placed between a CPU and main memory in order to enhance performance. See also level-one (L1) cache and level-two (L2) cache.

checkpointing -- One of the functions of the htepi_daemon; marking a filesystem state as clean after it flushes changed metadata to disk.

child process -- A new process created when a parent process calls the fork(S) system call.

clean -- The state of a memory page that has not had its contents altered.

client-server model -- A method of implementing application programs and operating system services which divides them into one of more client programs whose requests for service are satisfied by one or more server programs. The client-server model is suitable for implementing applications in a networked computer environment.

Examples of application of the client-server model are:

clock interrupt -- See clock tick.

clock tick -- An interrupt received at regular intervals from the programmable interrupt timer. This interrupt is used to invoke kernel activities that must be performed on a regular basis.

contention -- Occurs when several CPUs or processes need to access the same resource at the same time.

context -- The set of CPU register values and other data, including the u-area, that describe the state of a process.

context switch -- Occurs when the scheduler replaces one process executing on a CPU with another.

copy-on-write page -- A memory page that is shared by several processes until one tries to write to it. When this happens, the process is given its own private copy of the page.

COW page -- See copy-on-write page.

CPU -- Abbreviation of central processing unit. One or more CPUs give a computer the ability to execute software such as operating systems and application programs. Modern systems may use several auxiliary processors to reduce the load on the CPU(s).

CPU bound -- A system in which there is insufficient CPU power to keep the number of runnable processes on the run queue low. This results in poor interactive response by applications.

daemon -- A process that performs a service on behalf of the kernel. Since daemons spend most of their time sleeping, they usually do not consume much CPU power.

delayed-write buffer -- A system buffer whose contents must be written to disk before it can be reassigned.

device driver -- Performs I/O with a peripheral device on behalf of the operating system kernel. Most device drivers must be linked into the kernel before they can be used.

dirty -- The state of a memory page that has had its contents altered.

distributed interrupts -- Interrupts from devices that can be serviced by any CPU in a multiprocessor system.

event -- In the X Window System, an event is the notification that the X server sends an X client to tell it about changes such as keystrokes, mouse movement, or the moving or resizing of windows.

executing -- Describes machine instructions belonging to a program or the kernel being interpreted by a CPU.

fragmentation -- The propensity of the component disk blocks of a file or memory segments of a kernel data structure to become separated from each other. The greater the fragmentation, the more work has to be performed to retrieve the data.

free list -- A chain of unallocated data structures which are available for use.

garbage collection -- The process of compacting data structures to retrieve unused memory.

htepi_daemon -- A kernel daemon that handles filesystem metadata. It can also perform optional transaction intent logging and checkpointing on behalf of the HTFS filesystem.

idle -- The operating system is idle if no processes are ready-to-run or are sleeping while waiting for block I/O to complete.

idle waiting for I/O -- The operating system is idle waiting for I/O if processes that would otherwise be runnable are sleeping while waiting for I/O to a block device to complete.

in-core -- Describes something that is internal to the operating system kernel.

in-core inode -- An entry in the kernel table describing the status of a filesystem inode that is being accessed by processes.

inode -- Abbreviation of Index Node. An inode is a data structure that represents a file within a traditional UNIX filesystem. It consists of a file's metadata and the numbers of the blocks that can be used to access the file's data.

interrupt -- A notification from a hardware device about an event that is external to the CPU. Interrupts may be generated for events such as the completion of a transfer of data to or from disk, or a key being pressed.

interrupt bound -- A system which is unable to handle all the interrupts that are arriving.

interrupt latency -- The time that the kernel takes to handle an interrupt.

interrupt overrun -- Occurs when too many interrupts arrive while the kernel is trying to handle a previous interrupt.

I/O -- Abbreviation of input/output. The transfer of data to and from peripheral devices such as hard disks, tape drives, the keyboard, and the screen.

I/O bound -- A system in which the peripheral devices cannot transfer data as fast as requested.

job -- One or more processes grouped together but issued as a single command. For example, a job can be a shell script containing several commands or a series of commands issued on the command line connected by a pipeline.

kernel -- The name for the operating system's central set of intrinsic services. These services provide the interface between user processes and the system's hardware allowing access to virtual memory, I/O from and to peripheral devices, and sharing resources between the user processes running on the system.

kernel mode -- See system mode.

kernel parameter -- A constant defined in the file /etc/conf/cf.d/mtune (see mtune(F)) that controls the configuration of the kernel.

kmdaemon -- A kernel daemon that allocates pools on behalf of interrupt-level code, and tries to give memory back to the system.

level-one (L1) cache -- Cache memory that is implemented on the CPU itself.

level-two (L2) cache -- Cache memory that is implemented externally to the CPU.

load average -- The utilization of the CPU measured as the average number of processes on the run queue over a certain period of time.

logging -- See transaction intent logging.

marry driver -- A pseudo-device driver that allows a regular file within a filesystem to be accessed as a block device, and, hence, as a swap area.

memory bound -- A system which is short of physical memory, and in which pages of physical memory, but not their contents, must be shared by different processes. This is achieved by paging out, and swapping in cases of extreme shortage of physical memory.

memory leak -- An application program has a memory leak if its size is constantly growing in virtual memory. This may happen if the program is continually requesting more memory without re-using memory allocated to data structures that are no longer in use. A program with a memory leak can eventually make the whole system memory bound, at which time it may start paging out or swapping.

metadata -- The data that an inode stores concerning file attributes and directory entries.

multiprocessor system -- A computer system with more than one CPU.

multithreaded program -- A program is multithreaded if it can be accessed simultaneously by different CPUs. Multithreaded device drivers can run on any CPU in a multiprocessor system. The kernel is multithreaded to allow equal access by all CPUs to its tables and the scheduler. Only one copy of the kernel resides in memory.

namei cache -- A kernel data structure that stores the most-commonly accessed translations of filesystem pathname components to inode number. The namei cache improves I/O performance by reducing the need to retrieve such information from disk.

nice value -- A weighting factor in the range 0 to 39 that influences how great a share of CPU time a process will receive. A high value means that a process will run on the CPU less often.

non-blocking I/O -- Allows a process to continue executing without waiting for an I/O operation to complete. Also known as asynchronous I/O.

operating system -- The software that manages access to a computer system's hardware resources.

overhead -- The load that an operating system incurs while sharing resources between user processes and performing its internal accounting.

page -- A fixed-size (4KB) block of memory.

page fault -- A hardware event that occurs when a process tries to access an address in virtual memory that does not have a location in physical memory associated with it. In response, the system tries to load the appropriate data into a newly assigned physical page.

page stealing daemon -- The daemon responsible for releasing pages of memory for use by other processes. Also known as vhand.

paging in -- Reading pages of program text and pre-initialized data from the filesystems, or stack and data pages from swap.

paging out -- Releasing pages of physical memory for use by making temporary copies of the contents of dirty pages to swap space. Clean pages of program text and pre-initialized data are not copied to swap space because they can be paged in from the filesystems.

parent process -- A process that executes a fork(S) system call to create a new child process. The child process usually executes an exec(S) system call to invoke a new program in its place.

physical memory -- Storage implemented using RAM chips.

preemption -- A process that was running on a CPU is replaced by a higher priority process.

priority -- A value that the scheduler calculates to determine which process(es) should next run on the CPUs. A process' priority is calculated from its nice value and its recent CPU usage.

process -- A single instance of a program in execution. This can be a login shell or an operating system command, but not a built-in shell command. If a command is built into the shell a separate process is not created on its invocation; the built-in command is issued within the context of the shell process.

process table -- A data structure inside the kernel that stores information about all the processes that are present on a system.

protocol -- A set of rules and procedures used to establish and maintain communication between hardware or software subsystems.

protocol stack -- Allows two high-level systems to communicate by passing messages through a low-level physical interface.

pseudo-device driver -- A device driver that allows software to behave as though it is a physical device. Examples are ramdisks and pseudo-ttys.

pseudo-tty -- A pseudo-terminal is a device driver that allows one process to communicate with another as though it were a physical terminal. Pseudo-ttys are used to interface to programs that expect to receive non-blocking input and to send terminal control characters.

queue -- An ordered list of entities.

race condition -- The condition which occurs when several processes or CPUs are trying to write to the same memory or disk locations at the same time. The data that is eventually stored depends on the order that the writes occur. A synchronization mechanism must be used to enforce the desired order in which the writes are to take place.

RAID array -- Abbreviation of redundant array of inexpensive disks. Used to implement high performance and/or high integrity disk storage.

ramdisk -- A portion of physical memory configured to look like a physical disk but capable of fast access times. Data written to a ramdisk is lost when the operating system is shut down. Ramdisks are, therefore, only suitable for implementing temporary filesystems.

raw device interface -- Provides access to block-structured peripheral devices which bypasses the block device interface and allows variable-sized transfers of data. The raw interface also allows control of a peripheral using the ioctl(S) system call. This allows, for example, for low-level operations such as formatting a disk or rewinding a tape.

region -- A region groups a process' pages by their function. A process has at least three regions for its data, stack, and text.

resource -- Can be divided into software and hardware resources. Software resources may be specific to applications, or they may be kernel data structures such as the process table, open file, and in-core inode tables, buffer and namei caches, multiphysical buffers, and character lists. Hardware resources are a computer's physical subsystems. The three main subsystems are CPU, memory and I/O. The memory subsystem can be divided into two resources -- physical memory (or main memory) and swap space (or secondary memory). The I/O subsystem comprises one or more resources of similar or different types -- hard and floppy disk drives, tape drives, CD-ROMs, graphics displays and network devices.

ready-to-run process -- A process that has all the system resources that it needs in order to be able to run on a CPU.

response time -- The time taken between issuing a command and receiving some feedback from the system. This is not to be confused with turnaround time which is a measure of how long a particular task takes from invocation to completion.

run queue -- The list of ready-to-run processes maintained by the kernel.

runnable process -- See ready-to-run process.

scaling -- A computer system's ability to increase its processing capacity as CPUs are added. If the processing capacity increases in direct proportion to the number of CPUs, a system is said to exhibit 100% scaling. In practice, a system's ability to scale is limited by contention between the CPUs for resources and depends on the mix of applications being run.

sched -- The system name for the swapper daemon.

scheduler -- The part of the kernel that chooses which process(es) to run on the CPUs.

single threaded program -- A program is single threaded if it can only run on one CPU at a time. Single threaded devices drivers can only run on the base processor in a multiprocessor system.

sleeping on I/O -- See waiting for I/O.

spin lock -- A method of synchronizing processes on a multiprocessor system. A process waiting for a resource which is currently in use (locked) by a process running on a different CPU repeatedly executes a short section of kernel code (spins) until the lock is released.

stack -- A list of temporary data used by a program to handle function calls.

strd -- The system name for the STREAMS daemon.

stream head -- The level of the STREAMS I/O interface with which a user process communicates.

STREAMS daemon -- The daemon used by the STREAMS I/O subsystem to manage STREAMS memory.

STREAMS I/O -- A mechanism for implementing a layered interface between applications running in user space and a device driver. Most often used to implement network protocol stacks.

swap area -- A piece of swap space implemented as a disk division or as a block device married to a regular file in a filesystem.

swap space -- A collection of swap areas used to store the contents of stack and data memory pages temporarily while they are used by other processes.

swapper daemon -- Part of the kernel that reclaims physical pages of memory for use by copying whole regions of processes to swap space.

swapping -- The action take by the swapper daemon when the system is extremely short of physical memory needed for use by processes. Swapping can place a heavy load on the CPU and disk I/O subsystems.

symmetric multiprocessing -- A multiprocessor system is symmetric when any processor can perform any function. This ensures an even load distribution because no processor depends on another. Each process is executed by a single processor.

system mode -- The state of a CPU when the kernel needs to ensure that it has privileged access to its data and physical devices. Also known as kernel mode.

text -- Executable machine instructions (code) that a CPU can interpret and act on.

throughput -- The amount of work (measured in number of jobs completed, disk requests handled, and so on) that a system processes in a specified time.

time slice -- The maximum amount of time for which a process can run without being preempted.

transaction intent logging -- One of the functions of the htepi_daemon; writing the intention to change filesystem metadata to a log file on disk.

u-area -- Abbreviation of user area and also known as a u-block. A data structure possessed by every process. The u-area contains private data about the process that only the kernel may access.

user mode -- The state of a CPU when it is executing the code of a user program that accesses its own data space in memory.

vddaemon -- A kernel daemon that monitors and can reconfigure the operation of a virtual disk array.

vhand -- The system name for the page stealing daemon.

virtual disk -- A disk composed of pieces of several physical disks.

virtual memory -- A method of expanding the amount of available memory by combining physical memory (RAM) with cheaper and slower storage such as a swap area on a hard disk.

waiting for I/O -- A process goes to sleep if it has to wait for an I/O operation to complete.

X client -- An applications program that communicates with an X server to request that it display information on a screen or to receive input events from the keyboard or a pointing device such as a mouse. The client may be running on the same computer as the server (local), or it may be connected via a network (remote).

X server -- The software that controls the screen, keyboard and pointing device under the X Window System.

X terminal -- A display device that is able to run X server software. All of an X terminal's clients must run on remote machines.

X Window System -- A windowing system based on the client-server model.

zombie process -- An entry in the process table corresponding to a process that no longer exists. The entry will only be removed if its parent process invokes a wait(S) system call. A zombie process does not consume any system resources apart from its slot in the process table. However, you should beware of runaway processes that generate many zombies. These will cause the system to become short of memory as the process table grows to accommodate them.

© 2003 Caldera International, Inc. All rights reserved.
SCO OpenServer Release 5.0.7 -- 11 February 2003