This paper describes Cicero, a set of language constructs to allow constructive protocol specifications. Unlike other protocol specification languages, Cicero gives programmers explicit control over protocol execution, and facilitates both sequential and parallel implementations, especially for protocols above the transport-layer. It is intended to be used in conjunction with domain-specific libraries, and is quite different in philosophy and mode of use from existing protocol specification languages. A feature of Cicero is the use of event patterns to control synchrony, asynchrony, and concurrency in protocol execution, which helps programmers build robust protocol implementations. Event-pattern driven execution also enables implementers to exploit parallelism of varying grains in protocol execution. Event patterns can also be translated into other formal models, so that existing verification techniques may be used.

Many new remote procedure calls (RPC) systems are being built to meet different application requirements, and much development effort has been spent on redoing significant parts of the RPC system. This paper describes URPC, a toolkit for prototyping new RPC systems. It allows programmers to provide high-level implementations of RPC semantics and to customize supporting RPC services, such as stub generation and name service, to match the requirements of different RPC semantics. This approach increases flexibility in constructing new RPC systems and greatly reduces coding effort. In addition, this approach allows application-specific optimization by increasing the semantic content of individual RPC calls through customization, as well as by allowing programmers to import protocol machine implementations. Thus, the generated prototype RPC implementations can perform as fast as native RPCs.

Implementing efficient communication protocols is an important task in building distributed systems, but is complicated by the difficulties of dealing with complex multi-thread interactions and timing-related bugs. The paper describes Cicero, a set of language constructs designed to alleviate these difficulties. Cicero uses the notion of event patterns (C. V Ravishankar and R. Finkel, 1989) to help programmers build robust protocol implementations. Event patterns provide structure for controlling synchrony, asynchrony, and concurrency in protocol execution, and also allow implementers to exploit parallelism of varying grains. Event patterns can be translated into other formal models, so that existing verification techniques may be used. Our prototype implementation indicates that the total overhead imposed by event patterns accounts for less than 5% of the overall latency for protocols above the transport layer on single-processor implementations.>

Remote procedure call (RPC) is the most popular paradigm used today to build distributed systems and applications. As a consequence, the term "RPC" has grown to include a range of vastly different protocols above the transport layer. A resulting problem is that programs often use different RPC protocols, cannot be interconnected directly, and building a solution for each case in a large heterogeneous environment is prohibitively expensive. We describe the design of a system that can synthesize programs (RPC agents) to accommodate RPC heterogeneities. Because of its synthesis capability, the system also facilitates the design and implementation of new RPC protocols through rapid prototyping. We have built a prototype system to validate the design and to estimate the agent development costs and cross-RPC performance. The evaluation shows that the synthesis approach provides a more general solution than existing approaches do, and with lower software development and maintenance costs, while maintaining reasonable cross-RPC performance.>