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

Ru-Brd

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 .

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. Such objects generally execute service requests in a thread separate from the caller's (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.

Architectural Pattern: A pattern that expresses a fundamental structural organization schema for software systems. It provides a set of predefined subsystems, specifies their responsibilities, and includes rules and guidelines for organizing the relationships between them.

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

Asynchronous Completion Token (ACT): A developer-supplied value associated with an asynchronous operation. It is used to communicate information related to the operation to the operation's completion handler.

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.

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.

Bounded Buffer: A finite- sized buffer that allows two (or more) threads to share the buffer concurrently, with at least one thread inserting items into the buffer and at least one thread removing items from the buffer.

Bridge Pattern: A design pattern that decouples an abstraction from its implementation so that the two can vary independently.

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.

Cache Affinity: A thread scheduling optimization that gives preference to dispatching a thread on the CPU on which it most recently ran to maximize the probability of its state being present in the CPU's instruction and data caches.

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

Collocation: The locating of objects into a single process or host, often done to improve simplicity or performance (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 resources throughout a distributed system.

Completion Handler: An object whose interface contains one or more hook methods designed to process completion events.

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.

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

Condition Variable: 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.

Container: A common name for data structures that hold a collection of elements. Examples of containers are lists, sets, and associative arrays. In addition, component models, such as EJB and ActiveX Controls, define containers that provide a run-time environment that shields components from the details of their underlying infrastructure, such as an operating system.

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 .

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

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, endpoint 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.

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.

Double-Dispatching: This technique allows the execution of methods that depend on the type of request and the types of two receivers. The object that calls the method passes itself as a parameter to the receiver, so the receiver can act differently depending upon the type of the caller.

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

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

Event Handler: An object whose interface consists of one or more hook methods that can process application-specific events.

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

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]

Function Object: An object that can be called as if it is a function. Also known as a Functor.

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.

Hook Method: A framework-prescribed virtual method that acts as the target of framework-initiated callbacks. Use of hook methods is a technique for integrating application code with framework code.

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 nonportable aspects associated with developing networked applications via native OS APIs, such as Sockets or Pthreads.

Idiom: 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.

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.

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.

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

Latency: The delay experienced by operations.

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.

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.

Manager Pattern: This design pattern controls the life cycle of, or the access to, objects of a class.

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

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.

Mutex: 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 .

Nonrecursive Mutex: A mutex that must be released before it can be reacquired by any thread, including the thread originally holding it. 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.

Overlapped I/O: See [asynchronous I/O]

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 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.

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

Proactive I/O: An I/O method in which control returns to the caller initiating the operation immediately, often before the operation completes. The calling thread can perform other work while the OS carries out the I/O in parallel. The I/O operation's completion is noted at a later time. Compare with Reactive I/O .

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-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 ).

Quality of Service (QoS): A collection of policies and mechanisms designed to control and enhance communication properties, such as availability, 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.

Reactive I/O: An I/O model in which an application is notified when desired I/O operation(s) on a particular source are likely to succeed. The application then performs the desired operation(s) one at a time. Compare with Proactive I/O .

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.

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.

Robust Iterator: An iterator that ensures insertions and removals won't interfere with traversal.

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

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: See [Dynamically Linked Library (DLL)]

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 exchange data between connected peers. A passive-mode socket is a factory that returns a handle to a connected data-mode socket.

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.

Strategy Pattern: A design pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithms vary independently from clients that use it.

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

Synchronized Message Queue: A bounded buffer where producer threads can block if the queue is full and consumer threads can block if the queue is empty.

Synchronous Event Demultiplexer: A mechanism, usually a system function, that demultiplexes events from disparate sources, allowing them to be processed as part of an application's normal execution flow.

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-Scope Contention: A concurrency policy whereby the scope of threading or synchronization contention occurs between processes on a host (compare with Process-Scope Contention ).

Task: An autonomous or semi-autonomous portion of an application that performs some specific portion of the application's work, such as receive and demarshal network input, or process requests. A task is executed using one or more threads .

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.

Trojan Horse: A harmful piece of software that is hidden in a seemingly harmless software module such as a trusted run-time library.

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.

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

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 object-oriented interface.

Ru-Brd