We present a policy-based architecture STEPS for lifecycle management (LCM) in a mass scale distributed file system. The STEPS architecture is designed in the context of IBM's SAN file system (SFS) and leverages the parallelism and scalability offered by SFS, while providing a centralized point of control for policy-based management. The architecture uses novel concepts like policy cache and rate-controlled migration for efficient and non-intrusive execution of the LCM functions, while ensuring that the architecture scales with very large number of files. The architecture has been implemented and used for lifecycle management in a distributed deployment of SFS with heterogeneous data. We conduct experiments on the implementation to study the performance of the architecture. We observed that STEPS is highly scalable with increase in the number as well as the size of the file objects hosted by SFS. The performance study also demonstrated that most of the efficiency of policy execution is derived from policy cache. Further, a rate-control mechanism is necessary to ensure that users are isolated from LCM operations.

Multicast services, assisted by special hardware, are being considered as a part of high-speed wide-area networks (WANs) in order to support new generations of multiuser applications. The paper describes a multicast service application for high-speed WANs which is capable of exploiting multicast hardware. Indeed, this research was conducted in the context of the spanning tree hardware structure of PARIS and of plaNET, the pioneering broadband experimental networks that predated ATM. The results of this research were also included in IBM's ATM, called networking broadband services (NBBS). We achieve modularity and low cost by assigning to distinct components the separate problems of: 1) naming groups; 2) finding group members in a network; 3) configuring multicast hardware; 4) delivering multicast messages in sequence. This modularity enables, for example, the multicast, on one hand, to a group to which the user initiates the joining (formed by using 1 and 2 above) and, on the other hand, to groups computed by the source. We give the overall organization of our service and then describe in detail the methods used to solve the first two of the subproblems.

Cyclic redundancy check (CRC) is one of the most important error-detection schemes used in digital communications. A new parallel algorithm for CRC generation and its software as well as hardware implementation is described. For the software implementation, this paper has focused on the 32-bit CRC used in the Ethernet, computed on a general purpose PowerPC microprocessor with the new AltiVec technology. A speedup by a factor of 4.57 over the standard table-lookup algorithm was obtained. A hardware implementation of the algorithm is then discussed, which yields an unlimited speed-up potential over the bit-wise serial algorithm.

A control architecture for a high-speed packet-switched network is described. The architecture was designed and implemented as part of the PARIS (subsequently plaNET and BBNS) networking project at IBM. This high bandwidth network for integrated communication (data, voice, video) is currently operational as a laboratory prototype. It will also be deployed within the AURORA Testbed that is part of the NSF/DARPA gigabit networking program. The high bandwidth dictates the need for specialized hardware to support faster packet handling for both point-to-point and multicast connections. A faster and more efficient network control is also required in order to support the increased number of connections and their changing requirements with time. The new network control architecture presented exploits specialized hardware, thereby enabling tasks to be performed faster and with less computation overhead. In particular, since control information can be distributed quickly using hardware packet handling mechanisms, decisions can be made based upon more complete and accurate information. In some respects, this has the effect of having the benefits of centralized control (e.g., easier bandwidth resource allocation to connections), while retaining the fault tolerance and scalability of a distributed architecture.>

An application for multicast service for high-speed WANs (wide area networks) which is capable of exploiting multicast hardware is described. Modularity and low cost area achieved by assigning to distinct components the separate problems of (1) naming groups, (2) finding group members in a network, (3) configuring multicast hardware, and (4) delivering multicast messages in sequence. The overall organization of the service is given, along with the methods used to solve the first two subproblems.>

IntroductionWe describe the control protocols of the PARIS experimental network.This high bandwidth network for integrated communication (data, voice, video) ia currently operational as a laboratory prototype.It will also be deployed within the AURORA Testbed that is part of the NSF/DARPA Gigabit Networking program.The high bandwidth dictates the need of specialized hardware to support faster packet handling and control protocols.A new network control architecture is presented which exploits the specialized hardware in order to support the expected real time needs of future traffic.In particular, since control information can be distributed quickly, decisions can be made based upon more complete and accurate information.In some respects, this has the effect of having the benefits of centralized control (e.g.easier bandwidth resource allocation to connections), while retaining the fault-tolerance and scalability of a distributed architecture.

In this paper an algonthra for the determination of run-tune types m a programming language requiring no type declaratmns is presented It ~s demonstrated that this algorithm is superior to other pubhshed algortthms m the sense that it produces stronger assertions about the set of possible types for variables than do other known algorithms.In fact this algonthra is shown to be the best possible algorithm from among all those that use the same set of prumttve operators.

We present the best known algorithm for the determination of run-time types in a programming language requiring no type declarations. We demonstrate that it is superior to other published algorithms and that it is the best possible algorithm from among all those that use the same set of primitive operators.