File service is a fundamental computing requirement, but one that has been problematic for mobile users. Concerns about the latency associated with transferring large amounts of data over network connections of unknown quality have led to rather ad hoc approaches that provide some functionality, but with uncertain performance. Through a series of trace-driven simulation experiments, we investigate performance issues relating to providing remote file system support to mobile users through optimistic caching at the mobile client. Trade-offs between resources and performance are explored across a variety of design choices, specifically issues relating to the system configuration, policies for file system updates (write backs), and the choice of caching unit (whole-file caching or block-based caching). The results of our experiments show that it is possible to provide quite acceptable remote file service to weakly connected mobile clients, even when the bandwidth is limited. Reads can be serviced in a timely manner, updates can be committed in an acceptable period of time and resource requirements at the client are modest.

Distributed computing involves systems that operate across networks transparently, using the resources of multiple machines. The Open Software Foundation's Distributed Computing Environment (DCE) has evolved to address the need for a vendor-neutral platform to which distributed applications can be developed, and upon which they can run. Central to the design philosophy of DCE is its reliance on the remote procedure call (RPC) to facilitate communication among the entities in the distributed environment. Since it profoundly affects the performance of both the DCE environment and applications running on top of it, the performance of RPCs is very much a concern of both application developers and system managers in a DCE installation. This paper reports some results from an ongoing empirical investigation of the OS/2 DCE RPC facility. Our interest in this project is the effect on end-to-end RPC performance of protocol processing, flow control mechanisms within DCE, other load on the network, and interoperation with multiple DCE platforms.

Thii paper describes a new protocol to support IP multicast for mobile hosts in an IP internetwork.It uses the basic unicast routing capability of IETF Mobile IP as a foundation, and leverages existing IP multicast to provide multicast services for mobile hosts as well.We believe that the resulting scheme is simple, scalable, transparent, and to the extent possible, independent of the underlying multicast routing facility.Discrete-event simulation was used as the vehicle for a LLproof of concept" debugging of the protocol, as well as to determine its performance characteristics.A key feature of the new protocol is the use of designated multicast service providers (DMSPs) to address the scalability issues of mobile multicast.Our simulation results suggest distinct performance advantages of our protocol using DMSPs over two other approaches proposed for the mobile multicast problem, namely remote subscription and bi-directional tunnelling, particularly as the number of mobile group members increases.

Disk caches are employed in distributed file systems to avoid network accesses at clients and to compensate for the speed differential between main memory and disk at file servers. Because of concerns about volatility, however, write requests have typically not benefitted from the presence of caches. Instead, they have been processed with some sort of write-through or periodic write-back approach to ensure the integrity of the stored data. The introduction of reasonably priced non-volatile (NV) memories has prompted interest in the use of such memory for write caching, at the server and/or at the client. This paper describes an investigation through trace-driven simulation experiments of several approaches to write caching in distributed systems, with both volatile and non-volatile caches. The results support the findings of earlier work that suggests important differences between caching in the traditional single-level caching environment and caching in a two-level caching environment. While policies focusing on temporal locality perform well for a single-level caching system, or at the client of a two-level caching system, they may not be suitable for use at the server in a two-level caching system. This is because locality characteristics in the reference stream seen at the server in a two-level caching system may be destroyed by caching at the client with a NV write cache large enough to hold the client's working set of dirty blocks. Policies focusing on amortizing the cost of a disk seek operation over multiple write-back operations perform better at the server of a two-level caching system.

Trace driven simulations were used to study the performance of several disk cache replacement policies for network file servers. It is shown that locality based approaches, such as the common least recently used (LRU) policy, which are known to work well on stand-alone disked workstations and at client workstations in distributed systems, are inappropriate at a fileserver. Quite simple frequency based approaches do better. More sophisticated frequency based policies (eg., that take into account the file type) may offer additional improvements.>

The accuracy of the results of any performance study depends largely on the quality of the workload model driving it. Not surprisingly then, workload modelling is an area of great interest to those involved in the study of computer system performance. While a significant amount of research has focussed on the modelling of workloads in a centralized computer system, little has been done in the context of distributed systems. The goal of this research was to model the workload of a distributed system file server in a UNIX/NFS environment. The resulting model is distribution-driven and generates workload components in real time. It runs externally to the system it drives, thus eliminating any interference at the server. The model was validated for different workload intensities to ensure that it provides the flexibility to vary the workload intensity without loss of accuracy.

Processor scheduling on multiprocessor systems that simultaneously run concurrent applications is currently not well-understood. This paper reports a preliminary investigation of a number of fundamental issues which are important in the context of scheduling concurrent jobs on multiprogrammed parallel systems. The major motivation for this research is to gain insight into system behaviour and understand the basic principles underlying the performance of scheduling strategies in such parallel systems. Based on abstract models of systems and scheduling disciplines, several high level issues that are important in this context have been analysed.

A detailed quantitative study of program behaviour is described. Reference strings from a representative set of programs were decomposed into phases and transitions. Referencing behaviour is studied at both the macro level (program-wide) and the micro level (within the phases and transitions). Quantitative data, suitable for the parameterization of program behaviour models, is presented.

Recent research has demonstrated the existence of locality in short-term file referencing behaviour. A detailed study of the dynamic characteristics of file referencing is presented in this paper. The concept of Bounded Locality Intervals from the field of program behaviour has been used to model the locality phases of file referencing behaviour. The model is found to be powerful both from a descriptive point of view and from the perspective of understanding the performance implications of locality properties of file referencing behaviour on file system management.

The SCENT (Student Computing ENvironmenT) project is concerned with building an intelligent tutoring system to help student programmers debug their LISP programs. The major thrust of current SCENT investigations is into the design of the SCENT advisor which is meant to provide debugging assistance to novice students. Six conceptual levels constitute the advisor. At the lowest level is the “raw data,” consisting of the student's (possibly buggy) program. This can be interpreted by a “program behaviour” level which can produce traces, cross‐reference charts, etc. from the student's program. These traces, etc. can be analyzed by “observers” for interesting patterns. At the next level are “strategy judges” and “diagnosticians” which determine which strategy the student has used in his/her program and bugs in this strategy. A “task expert” provides task‐specific input into the process of analyzing the student's solution, and a “student‐knowledge component” provides student‐specific input into this process. Information from the six levels interacts in a variety of ways and control is similarly hierarchical. This necessitates a blackboard‐style scheme to coordinate information dissemination and control flow. This paper discusses the objectives of SCENT and focusses on organizing the process of debugging student programs. A complete example is given to illustrate how entities at the six levels interact and to indicate the kinds of information sharing that occur in the SCENT advisor. The paper concludes with an evaluation of the strengths and weaknesses of this approach to automated debugging, and suggestions about directions for further exploration.

The dynamic behavior of executing programs is a significant factor in the performance of virtual memory computer systems. Program restructuring attempts to improve the behavior of programs by reorganizing their object code to account for the characteristics of the virtual memory environment. A significant component of the restructuring process involves a restructuring graph. An analysis of restructuring graphs of typical programs found edge weights to be distributed in a Bradford–Zipf fashion, implying that a large fraction of total edge weight is concentrated in relatively few edges. This empirical observation can be used to improve the clustering phase of program restructuring, by limiting consideration to edges of large weight. We consider the effect of this improved clustering in the restructuring process by examining various means of restructuring some typical programs. In our experiments, 95 percent of the total edge value is typically accounted for by 50–60 percent of the edges. For naive clustering algorithms, clustering time is therefore typically halved; for more sophisticated methods, more substantial savings result. Finally, clustering with 95 percent of total edge value typically results in only a small decay in performance measures such as number of page faults and average working set size.

Although the phenomenon of locality has long been recognized as the single most important characteristic of program behaviour, relatively little work has been done in attempting to measure it. Recent work has led to the development of an intrinsic measure of program locality based on the Bradford-Zipf distribution. Potential applications for such a measure are many, and include the evaluation of program restructuring methods (manual and automatic), the prediction of system performance, the validation of program behaviour models, and the enhanced understanding of the phenomena that characterize program behaviour. A consideration of each of these areas is given in connection with the proposed measure, both to increase confidence in the validity of the measure and to illustrate a methodology for dealing with such problems.

The scheduler used in an operating system is an important factor in the performance of the system under heavy load. This paper describes the scheduling philosophy employed in the UNIX operating system and outlines the standard scheduling strategies. Modified strategies which address deficiencies in the standard strategies are described. The effectiveness of these modified strategies is assessed by means of performance experiments.

Although the phenomenon of locality has long been recognized as the single most important characteristic of program behaviour, little work has been done in attempting to measure it. Such a measure has potential application in the validation of program behaviour models, in the evaluation of program restructuring methods (manual and automatic), in performance prediction, and in the analysis of locality-sensitive experiments such as those involving page replacement algorithms. An approach to measuring the intrinsic locality of a program is proposed. Underlying principles of this locality measure are discussed and validation experiments are described. The results obtained demonstrate that measures derived independently of any execution environment can be valid measures of program locality. A detailed analysis of the proposed measure of locality is carried out and the results add to the growing knowledge of the behaviour of programs.