Showing papers on "Protocol (object-oriented programming) published in 1993"

An implementation of the contract net protocol based on marginal cost calculations

Abstract: This paper presents a formalization of the bidding and awarding decision process that was left undefined in the original contract net task allocation protocol This formalization is based on marginal cost calculations based on local agent criteria In this way, agents having very different local criteria (based on their selfinterest) can interact to distribute tasks so that the network as a whole functions more effectively In this model, both competitive and cooperative agents can interact In addition, the contract net protocol is extended to allow for clustering of tasks, to deal with the possibility of a large number of announcement and bid messages and to effectively handle situations, in which new bidding and awarding is being done during the period when the results of previous bids are unknown The protocol is verified by the TRACONET (TRAnsportation Cooperation' NET) system, where dispatch centers of different companies cooperate automatically in vehicle routing The implementation is asynchronous and truly distributed, and it provides the agents extensive autonomy The protocol is discussed in detail and test results with real data are presented

Selecting and locating graphical icon objects to define and configure the workstations in data processing networks

Abstract: A system and method for configuring communication and database networks in a user friendly graphical environment and automatically generating related configuration files. In a preferred practice, the user defines multiple network workstation nodes using icons, specifies the resources associated with each icon, defines connections between icons using specified protocol constraints, validates the network so defined, and generates the associated configuration files for the respective workstation nodes. The workstations have requester/server capability for communication and database network operation. The configuration files for the respective workstations in the network are preferably distributed and installed using the network resources. The network topology information so created can be stored, retrieved and modified as necessary to suit the needs of an evolving network.

File manager for files shared by heterogeneous clients

Abstract: A computer system manages files shared by first and second heterogeneous clients. The first client exhibits a first protocol such as SMB and the second client exhibits a second, different protocol such as NFS. A first protocol converter receives requests from the first client to create, read and update the files, and converts the requests to corresponding requests exhibiting a common protocol. A second protocol converter receives requests from the second client to create, read and update the files, and converts the requests to corresponding requests exhibiting the common protocol. A file manager is common to both clients and both protocol converters, receives the converted requests exhibiting the common protocol and executes the requests in a name space and data area which are both common to the first and second clients. The name space stores names of the files and the data area stores the files. The file manager provides access by each of the clients to files and names of the files created by the other client. A common lock manager is provided for the common name space and common data area. The system also supports second and third name spaces and data areas dedicated to the first and second clients, respectively.

Object-oriented networking system with dynamically configurable communication links

Abstract: Novel object-oriented client-server facility (CSF) and networking service facility (NSF) interfaces implement communication between application programs residing in client and server nodes of a distributed services network. The CSF interface includes remote procedure call (RPC) objects for invoking and responding to service requests at the nodes, and application programming interface (API) objects for transporting those requests between the nodes. However, the API objects only provide communication transports within a node. Accordingly, the API and RPC objects interact with dynamically-configurable protocol stacks within the NSF interfaces to complete the transport mechanism needed by an application program on the client node when accessing services on a remote server node. A preferred embodiment provides an efficient way to perform object operations in a broadcast fashion over a communication network and ensures the receipt and execution of the operation by each target of the broadcast.

Client server system and method of operation including a dynamically configurable protocol stack

Abstract: Novel object-oriented client-server facility (CSF) and networking service facility (NSF) interfaces implement communication between application programs residing in client and server nodes of a distributed services network. The CSF interface includes remote procedure call (RPC) objects for invoking and responding to service requests at the nodes, and application programming interface (API) objects for transporting those requests between the nodes. However, the API objects only provide communication transports within a node. Accordingly, the API and RPC objects interact with dynamically-configurable protocol stacks within the NSF interfaces to complete the transport mechanism needed by an application program on the client node when accessing services on a remote server node.

Users, user interfaces, and objects: Envision, a digital library

Abstract: Project Envision aims to build a “user-centered database from the computer science literature,” initially using the publications of the Association for Computing Machinery (ACM) Accordingly, we have interviewed potential users, as well as experts in library, information, and computer science—to understand their needs, to become aware of their perception of existing information systems, and to collect their recommendations Design and formative usability evaluation of our interface have been based on those interviews, leading to innovative query formulation and search results screens that work well according to our usability testing Our development of the Envision database, system software, and protocol for client-server communication builds upon work to identify and represent “objects” that will facilitate reuse and high-level communication of information from author to reader (user) All these efforts are leading not only to a usable prototype digital library but also to a set of nine principles for digital libraries, which we have tried to follow, covering issues of representation, architecture, and interfacing © 1993 John Wiley & Sons, Inc

A model for flexible high-performance communication subsystems

Abstract: A function-based communication model that allows applications to request individually tailored services from the communication subsystem is presented. Based on service requirements and available resources, suitable protocol machines are configured to serve the application. This configuration is done using a proper combination of functional modules. The concept of layering is therefore abandoned for both flexibility and efficiency reasons. >

Technique for communicating with electronic labels in an electronic price display system

Abstract: In a system for displaying prices in a retail store, an improved protocol is disclosed to permit improved communications between a host, or central computer and display devices Such a protocol enables the host to effectively communicate messages to the display devices for the latter to display information to consumers and/or store personnel

An Access Control Protocol, Sometimes Called TACACS

Abstract: This RFC documents the extended TACACS protocol use by the Cisco Systems terminal servers. This same protocol is used by the University of Minnesota's distributed authentication system. This memo provides information for the Internet community. It does not specify an Internet standard.

Information collection architecture and method for a data communications network

Abstract: A system and process are disclosed that allows the collection of events to be organized and ordered so that relationship between events and the events themselves can be identified as a state or series of states which describe and allow control of performance aspects of protocol activity. The architecture allows dynamic programming of multiple of devices for the purposes of coordination and correlation of events such that monitoring, performance analysis and control can be accomplished on a real-time basis for any speed network. The architecture facilitates feedback of the correlated events for the purposes of monitoring and controlling network activity.

The Internet Gopher Protocol (a distributed document search and retrieval protocol)

Abstract: The Internet Gopher protocol is designed for distributed document search and retrieval. This document describes the protocol, lists some of the implementations currently available, and has an overview of how to implement new client and server applications. This document is adapted from the basic Internet Gopher protocol document first issued by the Microcomputer Center at the University of Minnesota in 1991.

Object-oriented network protocol configuration system utilizing a dynamically configurable protocol stack

Abstract: Novel object-oriented client-server facility (CSF) and networking service facility (NSF) interfaces implement communication between application programs residing in client and server nodes of a distributed services network. The CSF interface includes remote procedure call (RPC) objects for invoking and responding to service requests at the nodes, and application programming interface (API) objects for transporting those requests between the nodes. However, the API objects only provide communication transports within a node. Accordingly, the API and RPC objects interact with dynamically-configurable protocol stacks within the NSF interfaces to complete the transport mechanism needed by an application program on the client node when accessing services on a remote server node.

ADAPTIVE: A dynamically assembled protocol transformation, integration and evaluation environment

Abstract: Computer communication systems must undergo significant changes to keep pace with the increasingly demanding and diverse multimedia applications that will run on the next generation of high-performance networks. To facilitate these changes, we are developing A Dynamically Assembled Protocol Transformation, Integration and evaluation Environment (ADAPTIVE). ADAPTIVE provides an integrated environment for developing and experimenting with flexible transport system architectures that support lightweight and adaptive communication protocols for diverse multimedia applications running on high-performance networks. Our approach employs a collection of reusable ‘building-block’ protocol mechanisms that may be composed together automatically based upon functional specifications. The resulting protocols execute in parallel on several target platforms including shared-memory and message-passing multiprocessors. ADAPTIVE provides a framework for (1) determining the functionality of customized lightweight protocol configurations that efficiently support multimedia applications and (2) mapping this functionality onto efficient parallel process architectures.

The Parallel Protocol Engine

Abstract: The design and implementation of a multiprocessor-based communication subsystem called the Parallel Protocol Engine (PPE), for the parallel and pipelined execution of protocols, are described. As an example, an implementation of the ISO 8802-2.2 logical link control on a four-processor version of the PPE is presented and analyzed. The performance of the implementation is more than 16,000 type-2 information protocol data units/s, commensurate with emerging high-speed networks that operate in the 100-Mb/s range. The overall end-to-end performance of an integrated system, where two workstations, each equipped with a PPE, communicate over a high-speed link, is analyzed and the problems concerning the soft- and hardware interface to the PPE are presented. >

Abstraction and modularity mechanisms for concurrent computing

Abstract: The Actor model programming language concept, which provides basic building blocks for a wide variety of computational structures, is reviewed. The Actor model unifies objects and concurrency. Actors are autonomous, distributed, concurrently executing objects that can send each other messages asynchronously. The Actor model's communication abstractions and object-oriented design are discussed. Three mechanisms for developing modular and reusable components for concurrent systems are also discussed. The mechanism are synchronizers, modular specifications of resource management policies, and protocol customization of dependability. >

Self-stabilization over unreliable communication media

Abstract: A self-stabilizing system has the property that it will converge to a desirable state when started from any state. Most previous researchers assumed that processes in self-stabilizing systems may communicate through shared variables while those that studied message passing systems allowed messages with unbounded size. This paper discusses the development of self-stabilizing systems which communicate through message passing, and in which messages may be lost in transit. The systems presented all use fixed size message headers. First, a self-stabilizing version of the Alternating Bit Protocol, a fundamental communication protocol for transmitting data across an unreliable communication medium, is presented. Secondly, the alternating-bit protocol is used to construct a self-stabilizing token ring.

A language-based approach to protocol implementation

Abstract: Morpheus is a special-purpose programming language that facilitates the efficient implementation of communication protocols. Protocols are divided into three categories, called shapes, so that they can inherit code and data structures based on their category. The programmer implements a particular protocol by refining the inherited structure. Morpheus optimization techniques reduce per-layer overhead on time-critical operations to a few assembler instructions even though the protocol stack is not determined until run time. This supports divide-and-conquer simplification of the programming task by minimizing the penalty for decomposing complex protocols into combinations of simpler protocols. >

Verification of Real-Time Systems Using PVS

Abstract: We present an approach to the verification of the real-time behavior of concurrent programs and describe its mechanization using the PVS proof checker. Our approach to real-time behavior extends previous verification techniques for concurrent programs by proposing a simple model for real-time computation and introducing a new operator for reasoning about absolute time. This model is formalized and mechanized within the higher-order logic of PVS. The interactive proof checker of PVS is used to develop the proofs of two illustrative examples: Fischer's real-time mutual exclusion protocol and a railroad crossing controller.

Network structure and a signalling protocol for a telecommunication network

Abstract: A network structure and a signalling protocol for a telecommunication network. The nodes (10, 11, 12) of the communication network are interconnected by a connection network (30) as well as a signalling network (41, 42, 50). Computer software (100) controlling the communication equipment (101, 102, 103) of each node is divided into two types of software, connection related software (210) and service related software (220). Connection related software groups (210) of different nodes communicate with each other via a first protocol (p211) while service related software groups (220) of different nodes communicate via a second protocol (p221) different from the first protocol. Between an originating node of a call and the terminating node of the same call a direct signalling path is established in the signalling network allowing for the addition of new service features in the originating and terminating nodes without the need to implement the new service features in the in between nodes via which the same call is routed in the connection network. A general signalling protocol supports the addition of new service features to existing nodes as well as the execution and management of the new services as well as of the services already existing in the telecommunication network. The signalling protocol (p221) is divided into a basic protocol (240) and one or more service specific protocols (241) called dialogues. The basic protocol is used to establish a signalling path between service related software groups in the originating and terminating nodes and to establish dialogues along said signalling path. This allows for a modular addition/removal of dialogues (241) to the basic protocol which remains unchanged.

Protocol verification made simple: a tutorial

Abstract: We describe how to define communication protocols, how to express protocol properties, and how to verify that the execution of a given protocol definition satisfies a given protocol property. The presentation is rarely opinionated, sometimes conversational, mostly rigorous, but always simple.

Distributed Programming in GARF

Abstract: GARF is an object-oriented programming environment aimed to support the design of reliable distributed applications. Its computational model is based on two programming levels: the functional level and the behavioral level. At the functional level, software functionalities are described using passive objects, named data objects, in a centralized, volatile, and failure free environment. At the behavioral level, data objects are dynamically bound to encapsulators and mailers which support distribution, concurrency, persistence and fault tolerance. Encapsulators wrap data objects by controlling how the latter send and receive messages, while mailers perform communications between encapsulators. This paper describes how the GARF computational model enables to build flexible and highly modular abstractions for the design of reliable distributed applications.

A Client-Server Protocol for the Composition of Petri Nets

Abstract: Modelling the behavior of a system as a set of cooperating nets requires to define a high-level communication protocol which takes into account the very nature of their interactions This paper proposes to adapt the client-server protocol promoted by the object-oriented approach to Petri nets, and to compose Petri nets according to this protocolThis protocol relies upon four basic rules which assert the honesty and discretion of clients and servers A class of nets respecting these rules, called clientserver nets, is defined, as is the composition of these nets according to a Use function The possibility to compose client-server nets while preserving the nets' language and liveness is studied This possibility comes down to very simple relationships between the main characteristics of client-server nets: the demand and the confidence degree as a client, and the supply and the reliability degree as a server These relationships are preserved by the composition of nets, so the client-server protocol allows for the incremental design of systems and favors the reuse of nets

A distributed protocol for channel-based communication with choice

Abstract: Recent attempts at incorporating concurrency into functional languages have identified synchronous communication via shared channels as a promising primitive. An additional useful feature found in many proposals is a nondeterministic choice operator. Similar in nature to the CSP alternative command, this operator allows different possible actions to be guarded by sends or receives. Choice is difficult to implement in a distributed environment because it requires offering many potential communications but closing only one. In this paper we present the first distributed, deadlock-free algorithm for choice

Design and analysis of dynamic leader election protocols in broadcast networks

Abstract: The well-known problem of leader election in distributed systems is considered in a dynamic context where processes may participate and crash spontaneously. Processes communicate by means of buffered broadcasting as opposed to usual point-to-point communication. In this paper we design a leader election protocol in such a dynamic context. As the problem at hand is considerably complex we develop the protocol in three steps. In the initial design processes are considered to be perfect and a leader is assumed to be present initially. In the second protocol, the assumption of an initial leader is dropped. This leads to a symmetric protocol which uses an (abstract) timeout mechanism to detect the absence of a leader. Finally, in the last step of the design processes may crash without giving any notification of other processes. The worst case message complexity of all protocols is addressed. A formal approach to the specification and verification of the leader election protocols is adopted. The requirements are specified in a property-oriented way and the protocols are denoted by means of extended finite state machines. It is proven using linear-time temporal logic that the fault-tolerant protocol satisfies its requirements.

Issues in Designing a Transport Protocol for Audio and Video Conferences and other Multiparticipant Real-Time Applications

Abstract: This memorandum is a companion document to the current version of the RTP protocol speci cation draft-ietf-avt-rtp-*.ftxt,psg. It discusses protocol aspects of transporting real-time services (for example, voice or video) over packet-switched networks such as the Internet. It compares and evaluates design alternatives for a real-time transport protocol, providing rationales for the design decisions made for RTP. Also covered are issues of port assignment and multicast address allocation. An appendix provides a comprehensive glossary of terms related to multimedia conferencing. This document is a product of the Audio-Video Transport working group within the Internet Engineering Task Force. Comments are solicited and should be addressed to the working group's mailing list at rem-conf@es.net and/or the author(s). INTERNET-DRAFT draft-ietf-avt-issues-02.ps May 9, 1994

Modeling replica divergence in a weak-consistency protocol for global-scale distributed data bases

Abstract: Distributed database systems for wide-area networks must scale to very large numbers of replicas in order to provide acceptable availability and response time. Weak-consistency replication protocols, such as the *timestamped anti-entropy* (TSAE) protocol we have developed, allow a database to scale to hundreds or thousands of replicas. The TSAE protocol allows updates to be processed by a single replica, then propagated from one replica to another in the background, causing replicas to temporarily diverge. The divergence is resolved in a short time and is resolved correctly even in the presence of temporary replica failure and network partition. We present a detailed analysis of the update propagation latency and the divergence between replicas caused by this protocol.

System for controlling communications between an application and a remote system using a protocol identifier and an application context identifier

Abstract: In a distributed system having a plurality of interconnected computer systems each having an application program, a process manager which determines the need for a communication process, determines an identifier of a destination system and a protocol and issues a communication process request in response to a process request for database access from the application program, and a virtual communication user for determining an application context in response to the communication process request from the process manager are provided, and a communication path a protocol machine establishes for the virtual communication user. A plurality of virtual communication users for managing the communication process are provided and each virtual communication user manages a plurality of protocol machines so that a plurality of protocols and application programs are simultaneously used for a plurality of destination systems from one application program.

An efficient and general implementation of futures on large scale shared-memory multiprocessors

Abstract: This thesis describes a high-performance implementation technique for Multilisp's "future" parallelism construct. This method addresses the non-uniform memory access (NUMA) problem inherent in large scale shared-memory multiprocessors. The technique is based on lazy task creation (LTC), a dynamic task partitioning mechanism that dramatically reduces the cost of task creation and consequently makes it possible to exploit fine grain parallelism. In LTC, idle processors get work to do by "stealing" tasks from other processors. A previously proposed implementation of LTC is the shared-memory (SM) protocol. The main disadvantage of the SM protocol is that it requires the stack to be cached suboptimally on cache-incoherent machines. This thesis proposes a new implementation technique for LTC that allows full caching of the stack: the message-passing (MP) protocol. Idle processors ask for work by sending "work request" messages to other processors. After receiving such a message a processor checks its private stack and task queue and sends back a task if one is available. The message passing protocol has the added benefits of a lower task creation cost and simpler algorithms. Extensive experiments evaluate the performance of both protocols on large shared-memory multiprocessors: a 90 processor GP1000 and a 32 processor TC2000. The results show that the MP protocol is consistently better than the SM protocol. The difference in performance is as high as a factor of two when a cache is available and a factor of 1.2 when a cache is not available. In addition, the thesis shows that the semantics of the Multilisp language does not have to be impoverished to attain good performance. The laziness of LTC can be exploited to support at virtually no cost several programming features including: the Katz-Weise continuation semantics with legitimacy, dynamic scoping, and fairness.

Process Membership in Asynchronous Environments

Abstract: The development of reliable distributed software is simplified by the ability to assume a fail-stop failure model. The emulation of such a model in an asynchronous distributed environment is discussed. The solution proposed, called Strong-GMP, can be supported through a highly efficient protocol, and was implemented as part of a distributed systems software project at Cornell University. The precise definition of the problem, the protocol, correctness proofs, and an analysis of costs are addressed.

An approach to constructing modular fault-tolerant protocols

Abstract: Modularization is a well-known technique for simplifying complex software. An approach to modularizing fault-tolerant protocols such as reliable multicast and membership is described. The approach is based on implementing a protocol's individual properties as separate microprotocols and then combining selected microprotocols using an event-driven software framework. A system is constructed by composing these frameworks with traditional network protocols using standard hierarchical techniques. In addition to simplifying the software, this model helps clarify the dependencies among properties of fault-tolerant protocols and makes it possible to construct systems that are customized to the specifics of the application or underlying architecture. An example involving reliable group multicast is given, together with a description of a prototype implementation using the SR concurrent programming language. >