William D. Roome

Design and implementation of a high-speed transport protocol

The design, analysis, and implementation of an end-to-end transport protocol that is capable of high throughput consistent with the evolving high-speed physical networks based on fiber-optic transmission lines and high-capacity switches are presented. Unlike current transport protocols in which changes in control/state information are exchanged between the two communicating entities only when some significant event occurs, this protocol exchanges relevant and full state information periodically and frequently. It is shown that this reduces the complexity of protocol processing by removing many of the procedures required to recover from network inadequacies such as bit errors, packet loss, and out-of-sequence packets and makes it more amenable to parallel processing. Also, to increase channel utilization in the presence of high-speed, long-latency networks and to support diagrams, and efficient implementation of the selective repeat method of error control is incorporated in the protocol. An implementation using a Motorola 68030-based multiprocessor as a front-end processor is described. The current implementation can comfortably handle 10-15 kpackets/s. >

Concurrent C++: concurrent programming with class(es)

C++ and Concurrent C are both upward‐compatible supersets of C that provide data abstraction and parallel programming facilities, respectively. Although data abstraction facilities are important for writing concurrent programs, we did not provide data abstraction facilities in Concurrent C because we did not want to duplicate the C++ research effort. Instead, we decided that we would eventually integrate C++ and Concurrent C facilities to produce a language with both data abstraction and parallel programming facilities, namely, Concurrent C++. Data abstraction and parallel programming facilities are orthogonal. Despite this, the merger of Concurrent C and C++ raised several integration issues.

Network-aware service placement in a distributed cloud environment

We consider a system of compute and storage resources geographically distributed over a large number of locations connected via a wide-area network. By distributing the resources, latency to users can be decreased, bandwidth costs reduced and availablility increased. The challenge is to distribute services with varying characteristics among the data centers optimally. Some services are very latency sensitive, others need vast amounts of storage, and yet others are computationally complex but do not require hard deadlines on execution. We propose efficient algorithms for the placement of services to get the maximum benefit from a distributed cloud systems. The algorithms need input on the status of the network, compute resources and data resources, which are matched to application requirements. This demonstration shows how a network-aware cloud can combine all three resource types - computation, storage, and network connectivity - in distributed cloud environments. Our dynamic service placement algorithm monitors the network and data center resources in real-time. Our prototype uses the information gathered to place or migrate services to provide the best user experience for a service.

Rendezvous facilities: Concurrent C and the Ada language

The concurrent programming facilities in both Concurrent C and the Ada language are based on the rendezvous concept. Although these facilities are similar, there are substantial differences. Facilities in Concurrent C were designed keeping in perspective the concurrent programming facilities in the Ada language and their limitations. Concurrent C facilities have also been modified as a result of experience with its initial implementations. The authors compare the concurrent programming facilities in Concurrent C and Ada and show that it is easier to write a variety of concurrent programs in Concurrent C than in Ada. >

The Silicon Database Machine

This paper describes the design of the hardware and software for a multiprocessor, silicon memory, database machine—the SiDBM. The entire database resides in stable silicon memory; there are no disks. The processors are functionally specialized, with relation managers, host interfaces, query managers, and query processors. The processors are tightly coupled, and the silicon memory is shared and is directly addressable by all of them. The SiDBM supports a relational model, and allows concurrent transactions and queries. The number of processors and the database size can be selected to suit the application; the expected range is 3 to 16 processors, and 100 megabytes to 2 gigabytes of data. This paper also gives some preliminary performance results for the SiDBM.

Experience with multiple processor versions of Concurrent C

Concurrent C, a superset of C providing parallel programming facilities, is considered. A uniprocessor version of Concurrent C was first implemented. After experience with this version, the Concurrent C implementation was extended to run on two types of multiple processor systems: a set of computers connected by a local area network (the distributed version) and a shared-memory multiprocessor (the multiprocessor version). Experience with implementing and using these versions of Concurrent C is described. Specifically, the language changes triggered by the multiple processor implementations, some sample programs, a comparison of the execution times on various systems, and the suitability of these multiple processor architectures are discussed. >

Implementing Concurrent C

Concurrent C (C++) is a parallel superset of C (C++). Versions of Concurrent C have now been implemented for a variety of uniprocessors and multiprocessors. We first implemented a uniprocessor version of Concurrent C correctly anticipating that it would be relatively easy to extend the uniprocessor implementation to run on multiprocessors. Concurrent C is translated to C. The generated C code contains calls to the C library implementing the Concurrent C run‐time system.

Monitoring and abstraction for networked clouds

We consider the problem of building tightly coupled network and cloud management systems for “carrier clouds” based on an abstract view of the dynamic network state. Optimized resource placement in distributed clouds requires information about the internal network topology and state, in addition to other data center information. We present a distributed cloud system that accesses such data in an abstract way using the Application Layer Traffic Optimization (ALTO) protocol. The demonstration addresses how dynamic networking information can be gathered, how it can be abstracted and coupled with other data such as data center load, how it can be exposed, and how it can be integrated into a cloud management system. Our distributed cloud solution demonstrates that ALTO is well-suited for infrastructure-to-application information exposure.

A novel software approach for service brokering in advanced service architectures

Service brokering considerably enhances advanced service architectures, such as IP Multimedia Subsystem (IMS), since the myriad applications potentially involved in a call or other session are located in the application layer and are separate and large grained. Through effective service brokering — that is, the effective blending and coordinating of services — interaction problems can be controlled and new composite services offering an enriched end-user experience can be provided. How can an effective service brokering capability be realized in a product when it must address needs not yet known? This question instigated the novel software approach (covered by filed Lucent patents) used in the Lucent Service Broker™ product. Adapting techniques used in Web servers and Session Initiation Protocol (SIP) servlet engines, but bringing to the design the special needs for service interaction and blending along with attendant needs for scalability and performance, the Lucent Service Broker was designed as a software engine with a powerful but easy-to-use API for customer programmability. This paper describes the software design of the Lucent Service Broker, particularly focusing on its novel aspects.

A general framework for concurrent simulation on neural network models

The analysis of complex neural network models via analytical techniques is often quite difficult due to the large numbers of components involved and the nonlinearities associated with these components. The authors present a framework for simulating neural networks as discrete event nonlinear dynamical systems. This includes neural network models whose components are described by continuous-time differential equations or by discrete-time difference equations. Specifically, the authors consider the design and construction of a concurrent object-oriented discrete event simulation environment for neural networks. The use of an object-oriented language provides the data abstraction facilities necessary to support modification and extension of the simulation system at a high level of abstraction. Furthermore, the ability to specify concurrent processing supports execution on parallel architectures. The use of this system is demonstrated by simulating a specific neural network model on a general-purpose parallel computer. >