Extensible operating systems allow applications to modify kernel behavior by providing mechanisms for application code to run in the kernel address space. Extensibility enables a system to efficiently support a broader class of applications than is currently supported. This paper discusses the key challenge in making extensible systems practical: determining which parts of the system need to be extended and how. The determination of which parts of the system need to be extended requires self-monitoring, capturing a significant quantity of data about the performance of the system. Determining how to extend the system requires self-adaptation. In this paper, we describe how an extensible operating system (VINO) can use in situ simulation to explore the efficacy of policy changes. This automatic exploration is applicable to other extensible operating systems and can make these systems self-adapting to workload demands.

The approach of program-driven simulation of multiprocessors has generally been believed to be too slow in order to perform experiments and performance evaluations with realistic workloads. We show that the program-driven approach for building multiprocessor simulators is indeed a viable method. It compares well in performance to an execution-driven simulator which has been reported in the literature, and has superior flexibility. The reported simulator is the core in the CacheMire test bench which is an entire environment for conducting performance evaluations on shared memory multiprocessors. The test bench is used in a number of projects, including cache coherence protocol evaluation, super-pipelined processor design and analysis of parallel program behaviour. 1

Performance orientation in the development process of parallel software is motivated by outlining the misconception of current approaches where performance activies come in at the very end of the development, mainly in terms of measurement or monitoring after the implementation phase. At that time major part of the development work is already done, and performance pitfalls are very hard to repair - if this is possible at all. A development process for parallel programs that launches performance engineering in the early design phase is proposed, based on a Petri net specification methodology for the performance critical parts of a parallel system. The Petri net formalism is used to define Program Resource Mapping-net (PRM-net) models, that serve as an integrated performance model of parallel processing systems, combining performance characteristics of parallel programs (P-net), parallel hardware (R-net) and the assignment of programs to hardware (Mapping) into a single performance model...

Long-run average properties of probabilistic systems refer to the average behavior of the system, measured over a period of time whose length diverges to infinity. These properties include many relevant performance and reliability indices, such as system throughput, average response time, and mean time between failures. In this paper, we argue that current formal specification methods cannot be used to specify long-run average properties of probabilistic systems. To enable the specification of these properties, we propose an approach based on the concept of experiments. Experiments are labeled graphs that can be used to describe behavior patterns of interest, such as the request for a resource followed by either a grant or a rejection. Experiments are meant to be performed infinitely often, and it is possible to specify their long-run average outcome or duration. We propose simple extensions of temporal logics based on experiments, and we present model-checking algorithms for the verif...

File system I/O is increasingly becoming a performance bottleneck in large distributed computer systems. lais is due to the increased file I/O demands of new applications, the inability of any single storage structure to respond to these demands, and the slow decline of disk access times (latency and seek) relative to the rapid increase in CPU speeds, memory size, and network bandwidth.

: A database system supporting a real-time application, which can be called `a real-time database system (RTDBS)', has to provide real-time information to the executing transactions. Each RTDB transaction is associated with a timing constraint, usually in the form of a deadline. Efficient resource scheduling algorithms and concurrency control protocols are required to schedule the transactions so as to satisfy both timing constraints and data consistency requirements. In this paper 1 , we concentrate on the concurrency control problem in RTDBS's. Our work has two basic goals: real-time performance evaluation of existing concurrency control approaches in RTDBS's, and proposing new concurrency control protocols with improved performance. One of the new protocols is locking-based, and it prevents the priority inversion problem 2 by scheduling the data lock requests based on prioritizing data items. The second new protocol extends the basic timestamp-ordering method by involving real-t...

Early performance estimates for a new software system aid the design process by providing feedback when design decisions can be easily revised. Unfortunately, constructing a performance model of a distributed and concurrent software system can require significant effort. An automated performance model generation technique is described that reduces the model building effort by providing: easy specification of performance experiments, empirical estimates for model parameters, automated model generation, and support for different types of models. A prototype is used to describe a software system, from which causal traces (angio traces) are recorded during execution. These traces are then processed into sequences of resource demands (workthreads), aggregated into system execution descriptions (workthread classes), and combined to generate a performance model. The technique can also be applied at other stages of the development process, including the redesign of existing software. Page ii...

In this thesis, we present a new methodology for resource sharing algorithms in distributed systems. We propose that a distributed computing system should be composed of a decentralized community of microeconomic agents. We show that this approach decreases complexity and can substantially improve performance. We compare the performance, generality and complexity of our algorithms with non-economic algorithms. To validate the usefulness of our approach, we present economies that solve three distinct resource management problems encountered in large, distributed systems. The first economy performs CPU load balancing and demonstrates how our approach limits complexity and effectively allocates resources when compared to non-economic algorithms. We show that the economy achieves better performance than a representative non-economic algorithm. The load balancing economy spa...

The introduction of powerful workstations connected through LAN networks inspired new DBMS architectures which offer high performance characteristics. In this paper, we examine three such software architecture configurations, namely: Client-Server (CS), RAD-UNIFY 1 type of DBMS (RU) and Enhanced ClientServer (ECS). Their specific functional components and design rationales are discussed. We use three simulation models to provide a performance comparison under different job workloads. Our simulation results show that the RU almost always performs slightly better than the CS especially under light workloads and that ECS offers significant performance improvement over both CS and RU. Under reasonable update rates, the ECS over CS (or RU) performance ratio is almost proportional to the number of participating clients (for less than 32 clients). We also examine the impact of certain key parameters on the performance of the three architectures and finally show that ECS is more ...

Load sharing can improve performance in distributed systems by transferring work from heavily loaded nodes to lightly loaded nodes. We propose a filter component to be included in a load sharing algorithm to detect short-lived jobs not worth considering for remote execution. One filter, called History, detects short-lived jobs by using job names and statistics based on previous executions. Job traces were collected from diskless workstations connected by a local area network and supported by a distributed file system. Trace driven simulation was then used to evaluate History with respect to other filters. Two load sharing algorithms showed significant improvement of the mean job response ratio when the History filter was added. 1 Introduction In a computing environment that consists of workstations, a high-speed interprocessor communication network, and shared resources such as file servers and printers, users often observe very unsatisfactory performance. This is often due to the imb...