Glossary | C++ Network Programming, Volume I: Mastering Complexity with ACE and Patterns

I l @ ve RuBoard

Abstract Class: A class that does not implement all the methods defined in its interface. An abstract class defines a common interface for its subclasses.

Acceptor-Connector Pattern: A design pattern that decouples the connection and initialization of cooperating peer services in a networked system from the processing they perform once connected and initialized .

Accidental Complexity: Complexity that arises as a side-effect of limitations with tools and techniques, such as type-unsafe APIs and procedural design, used to develop software within an application domain.

Active Connection Establishment: The connection role played by a peer application that initiates a connection to a remote peer (compare with Passive Connection Establishment).

Active Object: An object that implements the Active Object pattern (compare with Passive Object ).

Active Object Pattern: A design pattern that decouples method execution from method invocation in order to enhance concurrency and simplify synchronized access to objects that reside in their own threads of control.

Algorithmic Decomposition: A design paradigm in which programs are decomposed by functionality.

API: Application programming interface. The external interface of a software platform, such as an operating system, that is used by systems or applications built on top of it.

Aspects: A property of a program, such as memory management, synchronization, or fault tolerance, that cross-cuts module boundaries.

Asynchronous I/O: A mechanism for sending or receiving data in which an I/O operation is initiated but the caller does not block waiting for the operation to complete.

Bandwidth: The capacity of a communication medium, such as a network or bus.

Barrier Synchronization: A thread synchronization mechanism that allows a designated group of threads to synchronize their progress when each attains a certain state, such as completion of some collective operation or task. A barrier represents a specific point in the execution path . Each thread that reaches the barrier point waits for the other threads to also reach that point. When all threads in the set reach the barrier, the barrier is "dropped" and all threads simultaneously continue execution.

Broadcast: A broadcast is a special form of multicast, where messages are transmitted from a sender to all receivers in a particular domain.

Bus: A high-speed communication channel that links computing devices, such as CPUs, disks, and network interfaces.

Busy Wait: A technique used by a thread to wait for a lock by executing a tight loop and polling to see if the lock is available on each iteration, in contrast to waiting for the lock to be released by sleeping and allowing other threads to run.

Callback: An object registered with a dispatcher, which calls back to a method on the object when a particular event occurs.

Client: In our descriptions, client denotes a role, component, or subsystem that invokes or uses the functionality offered by other components .

Collocation: The activities associated with placing an object into the same process or host with the clients that access it. Collocation is often applied to improve locality of reference (compare with Distribution ).

Common Data Representation (CDR): The standard format defined by CORBA to marshal and demarshal data. It uses a bicanonical "receiver makes right" representation that only incurs overhead if the byte order of the sender differs from the byte order of the receiver.

Common Middleware Services: This layer of middleware defines domain-independent services, such as event notifications, logging, multimedia streaming, persistence, security, global time synchronization, real-time scheduling and distributed resource management, fault tolerance, concurrency control, and recoverable transactions, that allocate, schedule, and coordinate various esources throughout a distributed system.

Component: An encapsulated part of a software system that implements a specific service or set of services. A component has one or more interfaces that provide access to its services. Components serve as building blocks for the structure of a system. On a programming language level, components may be represented as modules, classes, objects, or a set of related functions. A component that does not implement all the elements of its interface is called an abstract component.

Component Configurator Pattern: A design pattern that allows an application to link and unlink its component implementations at run time without having to modify, recompile, or relink the application statically.

Concrete Class: A class from which objects can be instantiated . In contrast to abstract classes, all methods are implemented in a concrete class. The term is used to distinguish concrete subclasses from their abstract superclass.

Concurrency: The ability of an object, component, or system to execute operations that are "logically simultaneous" (compare with Parallelism ).

Condition Variable: A condition variable is a synchronization mechanism used by collaborating threads to suspend themselves temporarily until condition expressions involving data shared between the threads attain desired states. A condition variable is always used in conjunction with a mutex, which the thread must acquire before evaluating the condition expression. If the condition expression is false the thread atomically suspends itself on the condition variable and releases the mutex, so that other threads can change the shared data. When a cooperating thread changes this data, it can notify the condition variable, which atomically resumes a thread that had previously suspended on the condition variable and acquires its mutex again.

Connection: A full association that is used by peers to exchange data between endpoints of a network application.

Contention Scope: The domain in which a thread competes for resources (such as CPU time).; See also [ Process-Scope contention ]; See also [ System-Scope contention ]

Cooperative Cancelation: A thread cancelation mechanism implemented in ACE whereby the canceling thread requests one or more threads to cancel themselves. The threads are expected to honor the request at a convenient point, but are not forced to.

CORBA: The Common Object Request Broker Architecture (CORBA), a distributed object computing middleware standard defined by the Object Management Group (OMG).

Critical Section: Code that should not execute concurrently in an object or subsystem can be synchronized by a critical section. A critical section is a sequence of instructions that obeys the following invariant: while one thread or process is executing in the critical section, no other thread or process can execute in the critical section.

Daemon: A server process that runs continuously in the background performing various services on behalf of clients.

Data and Instruction Caches: Special high-speed memory collocated with a CPU that can improve overall system performance.

Data-Mode Socket: See [ Socket ]

Datagram: A self-contained, independent message that carries sufficient information to be routed from a source host to a destination host without relying on earlier exchanges between the source and destination host or the network.

Deadlock: A deadlock is a concurrency hazard that occurs when multiple threads attempt to acquire multiple locks and become blocked indefinitely in a circular wait state.

Deferred Cancelation: A thread cancelation mechanism whereby the cancelation is deferred until the to-be cancelled thread asks for any pending cancelation to be carried out.

Demarshaling: The conversion of a marshaled message to a host-specific format from a host-independent format.

Demultiplexing: A mechanism that routes incoming data from an input port to its intended receivers. There's a 1:N relationship between input port and receivers. Demultiplexing is commonly applied to incoming events and data streams. The reverse operation is known as multiplexing.

Design Pattern: A design pattern provides a scheme for refining components of a software system or the relationships between them. It describes a commonly-recurring structure of communicating components that solves a general design problem within a particular context.

Distribution: The activities associated with placing an object into a different process or host than the clients that access it. Distribution is often applied to improve fault tolerance or to access remote resources (compare with Collocation ).

Distribution Middleware: This layer of middleware automates common network programming tasks , such as connection and memory management, marshaling and demarshaling, end-point and request demultiplexing, synchronization, and multithreading, so that developers can program distributed applications much like stand-alone applications, that is, by invoking operations on target objects without concern for their location, language, OS, or hardware.

Domain: Denotes concepts, knowledge and other items that are related to a particular problem area. Often used in "application domain" to denote the problem area addressed by an application. On the Internet, a domain is a logical addressing entity, such as uci.edu or riverace.com.

Domain Analysis: An inductive, feedback-driven process that examines an application domain systematically to identify its core challenges and design dimensions in order to map them onto effective solution techniques.

Domain-Crossing Penalty: A performance cost incurred when system function calls cross from user-space to kernel-space. In addition to any interruption involved in changing to a privileged access mode, I/O calls must often copy data to and from user -space memory, adding to the delay.

Domain-specific Middleware Services: This layer of middleware defines services tailored to the requirements of particular domains, such as telecommunications or e-commerce. Domain-specific middleware services target specific vertical markets rather than the more broadly reusable services provided by underlying middleware layers .

Double-Checked Locking Optimization Pattern: A design pattern that reduces contention and synchronization overhead whenever critical sections of code must acquire locks in a thread-safe manner just once during program execution.

Dynamic Binding: A mechanism that defers the association of an operation name (a message) to the corresponding code (a method) until run time. Used to implement polymorphism in object-oriented languages.

Endpoint: The termination point of a connection.

Escape Hatch: A provision to allow use of a system feature in ways unforeseen by its designers.

Event: A message that conveys the occurrence of a significant activity, together with any data associated with the activity.

Event Loop: A program structure that continuously waits for and processes events.

Exception Safe: A component is exception safe if an exception raised in the component or propagated from a component called by the component does not cause resource leaks or an unstable state.

Factory: A method or function that creates and assembles the resources needed to instantiate and initialize an object or component instance.

Flow Control: A networking protocol mechanism that prevents a fast sender from overrunning the buffering and computing resources of a slow receiver.

Framework: See [ Object-Oriented Framework ]

Gather-Write: An output operation that transmits the contents of multiple noncontiguous data buffers in a single operation.

Generative Programming: A programming technique focusing on designing and implementing software components that can be combined to generate specialized and highly optimized systems that fulfill specific requirements.

Generic Programming: A programming technique that unites design patterns and C++ parameterized types to enable developers to achieve expressive, flexible, efficient, and highly reusable code.

Half-Sync/Half-Async Pattern: An architectural pattern that decouples asynchronous and synchronous processing in concurrent systems, to simplify programming without reducing performance unduly. This pattern introduces two intercommunicating layers, one for asynchronous and one for synchronous service processing. A queueing layer mediates communication between services in the asynchronous and synchronous layers.

Handle: A handle identifies resources that are managed by an operating system kernel. These resources commonly include, among others, network connections, open files, timers, and synchronization objects.

Host: An addressable computer attached to a network.

Host Infrastructure Middleware: This layer of middleware encapsulates concurrency and IPC mechanisms available on hosts to create OO network programming capabilities that eliminate many tedious , error-prone , and non-portable aspects associated with developing networked applications via native OS APIs, such as Sockets or Pthreads.

Hot Spot: A (usually small) section of code that is executed frequently.

Idiom: An idiom is a low-level pattern specific to a programming language. An idiom describes how to implement particular aspects of components or the relationships between them using the features of the given language.

Inherent Complexity: Complexity that arises from fundamental properties of a domain that complicate application development.; See also [ Accidental Complexity ]

Inheritance: A feature of object-oriented languages that allows new classes to be derived from existing ones. Inheritance defines implementation reuse, a subtype relationship, or both. Depending on the programming language, single or multiple inheritance is possible.

Inlining: A compile-time optimization technique that replaces a call to a function or method with the actual code body of that function or method. Inlining long function/method bodies can lead to code "bloat," with negative effects on storage consumption and paging.

Interface: A publicly accessible portion of a class, component, or subsystem.

Internet: A worldwide "network of networks" that is based on the Internet Protocol (IP). Widely considered to be the most important human invention since fire and MTV.

Internet Protocol (IP): A network layer protocol that performs "best-effort" segmentation, reassembly, and routing of packets.

Interprocess Communication (IPC): Communication between processes residing in separate address spaces. Examples of IPC mechanisms include shared memory, UNIX pipes, message queues, and socket communication.

Intranet: A network of computers within a company or other organization. Such a network may be secured from outside access and provide a platform for company-wide information exchange, cooperative work, and work flow, using Internet technologies for communication.

Jitter: The standard deviation of the latency for a series of operations.

Latency: The delay experienced by operations.

Layer: A level of abstraction that defines a particular set of services in a hierarchy. Layer _n is a consumer of services at layer _n _“1 and a supplier of services to layer _n ₊₁ .

Leader/Followers Pattern: An architectural pattern that provides an efficient concurrency model where multiple threads take turns sharing a set of event sources in order to detect, demultiplex, dispatch, and process service requests that occur on the event sources.

Least Frequently Used (LFU): A caching strategy in which the entry that was least frequently used is evicted first.

Least Recently Used (LRU): A caching strategy in which the entry that was least recently used is evicted first.

Linearization: The process of marshaling richly typed data, such as arrays, lists, or graphs, into a linear memory buffer.

Lock: A mechanism used to implement some type of a critical section. A lock that can be acquired and released serially , such as a static mutex, may be added to a class. If multiple threads attempt to acquire the lock simultaneously, only one thread will succeed and the others will block until the lock is available. Other locking mechanisms, such as semaphores or readers/writer locks, define different synchronization semantics.

Lock-Step: A protocol design paradigm that requires a request to be replied to before a subsequent request is issued.

Marshaling: The conversion of a set of data from a host-specific format into a host-independent format.

Memory Management Unit (MMU): An MMU protects separate process address spaces from accidental or malicious corruption by other active processes in the system.

Message: Messages are used to communicate between objects, threads, or processes. In an object-oriented system the term message is used to describe the selection and activation of an operation or the method of an object. This type of message is synchronous, which means that the sender waits until the receiver finishes the activated operation. Threads and processes often communicate asynchronously, in which the sender continues its execution without waiting for the receiver to reply.

Message Passing: An IPC mechanism used to exchange messages between threads or processes (compare with Shared Memory ).

Middleware: A set of layers and components that provides reusable common services and network programming mechanisms. Middleware resides on top of an operating system and its protocol stacks but below the structure and functionality of any particular application.

Monitor Object Pattern: A design pattern that synchronizes the execution of concurrent methods to ensure that only one method at a time runs within an object. It also allows an object's methods to schedule their execution sequences cooperatively.

Multicast: A networking protocol that allows a sender to transmit messages efficiently to multiple receivers (compare with Unicast ).

Mutex: A mutex is a "mutual exclusion" locking mechanism that ensures only one thread at a time is active concurrently within a critical section in order to prevent race conditions.

Networked Application Architecture: An architecture that facilitates the use of software components and resources that can be placed throughout a distributed system and used to execute networked applications.

Nonrecursive Mutex: A mutex that must be released before it can be re-acquired by any thread. Compare with Recursive Mutex.

Object-Oriented Framework: An integrated set of classes that collaborate to provide a reusable software architecture for a family of related applications. In an object-oriented environment a framework consists of abstract and concrete classes. Instantiation of such a framework consists of composing and subclassing from existing classes.

Object Request Broker: A middleware layer that allows clients to invoke methods on distributed objects without concern for object location, programming language, operating system platform, networking protocols, or hardware.

One-Way Method Invocation: A call to a method that passes parameters to a server object but does not receive any results from the server (compare with Two - Way Method Invocation ).

Out-of- Band Data: Data that is delivered outside of the normal byte stream traffic; also known as urgent data.

Parallelism: The ability of an object, component, or system to execute operations that are "physically simultaneous" (compare with Concurrency ).

Parameterized Type: A programming language feature that allows classes to be parameterized by various other types (compare with Template ).

Passive Connection Establishment: The connection role played by a peer application that accepts a connection from a remote peer (compare with Active Connection Establishment ).

Passive-Mode Socket: See [ Socket ]

Passive Object: An object that borrows the thread of its caller to execute its methods (compare with Active Object ).

Pattern: A pattern describes a particular recurring design problem that arises in specific design contexts and presents a well-proven solution for the problem. The solution is specified by describing its constituent participants , their responsibilities and relationships, and the ways in which they collaborate.

Pattern Language: A family of interrelated patterns that define a process for resolving software development problems systematically.

Peer-to-Peer: In a distributed system peers are processes that communicate with each other. In contrast to components in client-server architectures, peers may act as clients, as servers, or as both, and may change these roles dynamically.

Pipes and Filters Pattern: An architectural pattern that provides a structure for systems that process a stream of data.

Platform: The combination of hardware and/or software that a system uses for its implementation. Software platforms include operating systems, libraries, and frameworks. A platform implements a virtual machine with applications running on top of it.

Port Number: A 16-bit number used to identify an endpoint of communication in the TCP protocol.

Priority Inversion: A scheduling hazard that occurs when a lower-priority thread or request blocks the execution of a higher-priority thread or request.

Proactor Pattern: An architectural pattern that allows event-driven applications to efficiently demultiplex and dispatch service requests triggered by the completion of asynchronous operations, to achieve the performance benefits of concurrency without incurring certain of its liabilities.

Process: A process provides resources, such as virtual memory, and protection capabilities, such as user/group identifiers and a hardware-protected address space, that can be used by one or more threads in the process. Compared with a thread, however, a process maintains more state information, requires more overhead to spawn, synchronize, and schedule, and often communicates with other processes via message passing or shared memory.

Process-Scope contention: A concurrency policy whereby the scope of threading or synchronization contention occurs within a process on a host (compare with System-Scope Contention ).

Protocol: A set of rules that describe how messages are exchanged between communicating peers, as well as the syntax and semantics of these messages.

Protocol Stack: A group of hierarchically layered protocols.

Quality of Service (QoS): A collection of policies and mechanisms designed to control and enhance communication properties, such as bandwidth, latency, and jitter.

Race Condition: A race condition is a concurrency hazard that can occur when multiple threads simultaneously execute within a critical section that is not properly serialized.

Reactor Pattern: An architectural pattern that allows event-driven applications to demultiplex and dispatch service requests that are delivered to an application from one or more clients.

Readers/Writer Lock: A lock that allows multiple threads to access a resource concurrently, but allows only one thread at a time to modify the resource and further prevents concurrent access and modifications.

Recursive Mutex: A lock that can be reacquired by the thread that owns the mutex without incurring self-deadlock on the thread. Compare with Nonrecursive Mutex.

Refactoring: An incremental activity that abstracts general-purpose behavior from existing software to enhance the structure and reusability of components and frameworks.

Reify: The act of creating a concrete instance of an abstraction. For example, a concrete reactor implementation reifies the Reactor pattern and an object reifies a class.

Ripple Effect: The phenomenon of having to making changes necessitated by a previous change's side effects. Picture the ripples emanating from a rock dropped into a calm lake.

Scatter-Read: An input operation that stores data into multiple caller-supplied buffers instead of a single contiguous buffer.

Scheduler: A mechanism that determines the order in which threads or events are executed.

Scoped Locking Idiom: A C++ idiom that ensures a lock is acquired when control enters a scope and released automatically when control leaves the scope, regardless of the return path from the scope.

Semaphore: A locking mechanism that maintains a count. As long as the count is greater than zero a thread can acquire the semaphore without blocking. After the count becomes zero, however, threads block on the semaphore until its count becomes greater than zero as a result of another thread releasing the semaphore, which increments the count.

Serialization: A mechanism for ensuring that only one thread at a time executes within a critical section in order to prevent race conditions.

Service: In the context of network programming, a service can either be (1) a well-defined capability offered by a server, such as the ECHO service provided by the Inetd super-server, (2) a collection of capabilities offered by a server daemon, such as the INETD super-server itself, or (3) a collection of server processes that cooperate to achieve a common task, such as a collection of RWHO daemons in a local area network (LAN) subnet that periodically broadcast and receive status information reporting user activities to other hosts.

Shared Library: A library that can be shared by multiple processes and linked into and out of a process address space dynamically in order to improve application flexibility and extensibility at run time (also known as a Dynamically Linked Library, or DLL).

Shared Memory: An operating system mechanism that allows multiple processes on a computer to share a common memory segment (compare with Message Passing ).

Sleep-Lock: A synchronization implementation that waits for a lock to be released by sleeping and allowing other threads to run (compare with Spin-Lock ).

Smart Pointer: A smart pointer is a C++ object that looks and acts like a built-in pointer but can achieve effects, such as caching, persistence, or thread-specific storage access, that built-in pointers don't support.

Socket: A family of terms related to network programming. A socket is an endpoint of communication that identifies a particular network address and port number. The Socket API is a set of function calls supported by most operating systems and used by network applications to establish connections and communicate via socket endpoints. A data-mode socket can be used to exchanged data between connected peers. A passive-mode socket is a factory that returns a handle to a connected data-mode socket.

Spin-Lock: A synchronization implementation that waits for a lock by executing a tight loop and polling to see if the lock is available on each iteration (compare with Sleep-Lock ).

Stand-Alone Application Architecture: An architecture that requires all of the application's components and resources to be in one computer that does not rely on another to execute the application.

Starvation: A scheduling hazard that occurs when one or more threads are continually preempted by higher-priority threads and never execute.

Strategized Locking Pattern: A design pattern that parameterizes synchronization mechanisms that protect a component's critical sections from concurrent access.

Synchronization Mechanism: A locking mechanism that coordinates the order in which threads execute.

Synchronous I/O: A mechanism for sending or receiving data in which an I/O operation is initiated and the caller blocks waiting for the operation to complete.

System: A collection of software and/or hardware performing one or several services. A system can be a platform, an application, or both.

System-Scope contention: A concurrency policy whereby the scope of threading or synchronization contention occurs between processes on a host (compare with Process-Scope Contention ).

Template: A C++ programming language feature that enables classes and functions to be parameterized by various types, constants, or pointers to functions. A template is often called a generic or parameterized type.

Thread: An independent sequence of instructions that executes within an address space that can be shared with other threads. Each thread has its own run-time stack and registers, which enables it to perform synchronous I/O without blocking other threads that are executing concurrently. Compared to processes, threads maintain minimal state information, require relatively little overhead to spawn, synchronize and schedule, and usually communicate with other threads via objects in their process's memory space, rather than shared memory.

Thread-Per-Connection: A concurrency model that associates a separate thread with each network connection. This model handles each client that connects with a server in a separate thread for the duration of the connection. It is useful for servers that must support long-duration sessions with multiple clients. It is not useful for clients, such as HTTP 1.0 Web browsers, that associate a single request with each connection, which is effectively a thread per request model.

Thread-Per-Request: A concurrency model that spawns a new thread for each request. This model is useful for servers that must handle long-duration request events from multiple clients, such as database queries. It is less useful for short-duration requests, due to the overhead of creating a new thread for each request. It can also consume a large number of operating system resources if many clients send requests simultaneously.

Thread Pool: A concurrency model that allocates a set of threads that can perform requests simultaneously. This model is a variant of thread per request that amortizes thread creation costs by prespawning a pool of threads. It is useful for servers that want to limit the number of operating system resources they consume. Client requests can be executed concurrently until the number of simultaneous requests exceeds the number of threads in the pool. At this point, additional requests must be queued until a thread becomes available.

Thread-Safe: Safe from any undesired side effects ( race conditions, data collisions, etc.) caused by multiple threads executing the same section of code concurrently.

Thread-Safe Interface Pattern: A design pattern that minimizes locking overhead and ensures that intracomponent method calls do not incur "self-deadlock" by trying to reacquire a lock that is held by the component already.

Thread-Specific Storage (TSS) Pattern: A design pattern that allows multiple threads to use one "logically global" access point to retrieve an object that is local to a thread, without incurring locking overhead on each object access.

Traits: A type that conveys information used by another class or algorithm to determine policies or implementation details at compile time.

Transmission Control Protocol (TCP): A connection-oriented transport protocol that exchanges byte streams of data reliably, in order, and unduplicated between a local and remote endpoint.

Transport Layer: The layer in a protocol stack that is responsible for end to end data transfer and connection management.

Transport Layer Interface (TLI): TLI is a set of function calls provided in System V UNIX and used by network applications to establish connections and communicate via connected transport endpoints.

Type Safe: A property enforced by a programming language's type system to ensure that only valid operations can be invoked upon instances of types.

Unicast: A networking protocol that allows a sender to transmit messages to a single receiver (compare with Multicast ).

Unicode: A standard for character representation that includes characters for most written languages as well as representations for punctuation, mathematical notations, and other symbols.

Unreliable Transport Protocol: A transport protocol that makes no guarantee concerning transmitted data's disposition; it may never arrive, arrive out of order, or arrive multiple times.

User Datagram Protocol (UDP): An unreliable, connectionless transport protocol that exchanges datagram messages between local and remote endpoints.

Virtual Machine: An abstraction layer that offers a set of services to higher-level applications or other virtual machines.

Virtual Memory: An operating system mechanism that permits developers to program applications whose address space is larger than the amount of physical memory on the computer.

Weakly Typed: A datum whose declared data type does not fully reflect its intended or purported use.

Wrapper Facade: One or more classes that encapsulate functions and data within a type safe OO interface.

Zombie: A process that's exited, but which still occupies a process table slot. A zombie remains in this state until a parent process obtains its exit status.

I l @ ve RuBoard