Person:
Small, Christopher

Profile Picture

Email Address

AA Acceptance Date

Birth Date

Research Projects

Organizational Units

Job Title

Last Name

Small

First Name

Christopher

Name

Small, Christopher

Filters

1994 - 199982000 - 20051

Settings

Author's Publications: search.filters.isAuthorOfPublication.eea9f071-4775-43ba-b572-da96587012b4

Search Results

Now showing 1 - 9 of 9
  • Thumbnail Image
    Publication
    Scheduler Activations on BSD: Sharing Thread Management Between Kernel and Application
    (1995) Small, Christopher; Seltzer, Margo
    There are two commonly used thread models: kernel level threads and user level threads. Kernel level threads suffer from the cost of frequent user-kernel domain crossings and fixed kernel scheduling priorities. User level threads are not integrated with the kernel, blocking all threads whenever one thread is blocked. The Scheduler Activations model, proposed by Anderson et al. [ANDE91], combines kernel CPU al location decisions with application control over thread scheduling. This paper discusses the performance characteristics of an implementation of Scheduler Activations for a uniprocessor BSD system, and proposes an analytic model for determining the class of applications that benefit from its use. Our implementation required fewer than two hundred lines of kernel code and provides an order of magnitude performance improvement over process-level facilities.
  • Thumbnail Image
    Publication
    Does Systems Research Measure Up?
    (1997) Small, Christopher; Ghosh, Narendra; Saleeb, Hany; Seltzer, Margo; Smith, Keith
    We surveyed more than two hundred systems research papers published in the last six years, and found that, in experiment after experiment, systems researchers measure the same things, but in the majority of cases the reported results are not reproducible, comparable, or statistically rigorous. In this paper we present data describing the state of systems experimentation and suggest guidelines for structuring commonly run experiments, so that results from work by different researchers can be compared more easily. We conclude with recommendations on how to improve the rigor of published computer systems research.
  • Thumbnail Image
    Publication
    A Revisitation of Kernel Synchronization Schemes
    (1997) Small, Christopher; Manley, Stephen
    In an operating system kernel, critical sections of code must be protected from interruption. This is traditionally accomplished by masking the set of interrupts whose handlers interfere with the correct operation of the critical section. Because it can be expensive to communicate with an off-chip interrupt controller, more complex optimistic techniques for masking interrupts have been pro-posed. In this paper we present measurements of the behavior of the NetBSD 1.2 kernel, and use the measurements to explore the space of kernel synchronization schemes. We show that (a) most critical sections are very short, (b) very few are ever interrupted, (c) using the traditional synchronization technique, the synchronization cost is often higher than the time spent in the body of the critical section, and (d) under heavy load NetBSD 1.2 can spend 9% to 12% of its time in synchronization primitives. The simplest scheme we examined, disabling all interrupts while in a critical section or interrupt handler, can lead to loss of data under heavy load. A more complex optimistic scheme functions correctly under the heavy workloads we tested and has very low overhead (at most 0.3%). Based on our measurements, we present a new model that offers the simplicity of the traditional scheme with the performance of the optimistic schemes. Given the relative CPU, memory, and device performance of today’s hardware, the newer techniques we examined have a much lower synchronization cost than the traditional technique. Under heavy load, such as that incurred by a web server, a system using these newer techniques will have noticeably better performance.
  • Thumbnail Image
    Publication
    VINO: An Integrated Platform for Operating System and Database Research
    (1994) Small, Christopher; Seltzer, Margo
    In 1981, Stonebraker wrote: "Operating system services in many existing systems are either too slow or inappropriate. Current DBMSs usually provide their own and make little or no use of those offered by the operating system." The standard operating system model has changed little since that time, and we believe that, at its core, it is the wrong model for DBMS and other resource-intensive applications. The standard model is in inflexible, uncooperative, and irregular in its treatment of resources. We describe the design of a new system, the VINO kernel, which addresses the limitations of standard operating systems. It focuses on three key ideas: 1.) Applications direct policy. 2.) Kernel mechanisms are reusable by applications. 3.) All resources share a common extensible interface. VINO's power and flexibility make it an ideal platform for the design and implementation of traditional and modern database management systems.
  • Thumbnail Image
    Publication
    The Case for Extensible Operating Systems
    (1996) Seltzer, Margo; Small, Christopher; Smith, Keith
    Many of the performance improvements cited in recent operating systems research describe specific enhancements to normal operating system functionality that improve performance in a set of designated test cases. Global changes of this sort can improve performance for one application, at the cost of decreasing performance for others. We argue that this flurry of global kernel tweaking is an indication that our current operating system model is inappropriate. Existing interfaces do not provide the flexibility to tune the kernel on a per-application basis, to suit the variety of applications that we now see. We have failed in the past to be omniscient about future operating system requirements; there is no reason to believe that we will fare any better designing a new, fixed kernel interface today. Instead, the only general-purpose solution is to build an operating system interface that is easily extended. We present a kernel framework designed to support the application-specific customization that is beginning to dominate the operating system literature. We show how this model enables easy implementation of many of the earlier research results. We then analyze two specific kernel policies: page read-ahead and locking-granting. We show that application-control over read-ahead policy produces performance improvements of up to 16%. We then show how application-control over the lock-granting policy can choose between fairness and response time. Reader priority algorithms produce lower read response time at the cost of writer starvation. FIFO algorithms avoid the starvation problem, but increase read response time.
  • Thumbnail Image
    Publication
    VINO: The 1994 Fall Harvest
    (1994) Endo, Yasuhiro; Seltzer, Margo; Small, Christopher; Smith, Keith
    Current operating systems are designed to provide least-common-denominator service to a variety of applications. They export few internal kernel facilities, and those which are exported have irregular interfaces. As a result, resource intensive applications such as database management systems and multimedia applications, are often poorly served by the operating system. These applications often go to great lengths to bypass normal kernel mechanisms to achieve acceptable performance. We describe a new kernel architecture, the VINO kernel, which addresses the limitations of conventional operating systems. The VINO design is driven by three principles: 1.) Application Directed Policy: the operating system provides a collection of mechanisms, but applications dictate the policies applied to those mechanisms. 2.) Kernel as Toolbox: applications can reuse the kernel's primitives. 3.) Universal Resource Access: all resources are accessed through a single, common interface. VINO's power and flexibility make it an ideal platform for research in operating systems and resource intensive applications.
  • Thumbnail Image
    Publication
    MiSFIT: A Freely Available Tool for Building Safe Extensible Systems
    (1996) Small, Christopher
    The boundary between application and system is becoming increasingly permeable. Extensible database systems, operating systems, and applications, such as web browsers, are demonstrating the value of allowing end-users to extend and modify the behavior of what formerly was considered to be a static, inviolate system. Unfortunately, flexibility often comes with a cost: systems unprotected from misbehaved end-user extensions are fragile and prone to instability. There are three common methods for making end-user extensions safe: restrict the extension language, interpret the extension language, or add run-time checks to binary code that ensure the safety of an otherwise unsafe program. The third technique, software fault isolation, offers the twin benefits of the performance of compiled code and the flexibility to choose an unsafe language, such as C or C++. MiSFIT, a tool for software fault isolation of x86 code, transforms unsafe C or C++ into safe binary code. The performance overhead of using MiSFIT to protect against stray writes and arbitrary function calls is low, on the order of ten percent.
  • Thumbnail Image
    Publication
    Issues in Extensible Operating Systems
    (1997) Seltzer, Margo; Endo, Yasuhiro; Small, Christopher; Smith, Keith A.
    Operating systems research has traditionally consisted of adding functionality to the operating system or inventing and evaluating new methods for performing functions. Regardless of the research goal, the single constant has been that the size and complexity of operating systems increase over time. As a result, operating systems are usually the single most complex piece of software in a computer system, containing hundreds of thousands, if not millions, of lines of code. Today’s operating system research is directed at finding new ways to structure the operating system in order to increase its flexibility, allowing it to adapt to changes in the application set it must support. This paper discusses the issues involved in designing such extensible systems and the array of choices facing the operating system designer. We present a framework for describing extensible operating systems and then relate current operating systems to this framework.
  • Thumbnail Image
    Publication
    Performance of Multithreaded Chip Multiprocessors And Implications for Operating System Design
    (2005) Fedorova, Alexandra; Seltzer, Margo; Small, Christopher; Nussbaum, Daniel
    An operating system’s design is often influenced by the architecture of the target hardware. While uniprocessor and multiprocessor architectures are well understood, such is not the case for multithreaded chip multiprocessors (CMT) – a new generation of processors designed to improve performance of memory-intensive applications. The first systems equipped with CMT processors are just becoming available, so it is critical that we now understand how to obtain the best performance from such systems. The goal of our work is to understand the fundamentals of CMT performance and identify the implications for operating system design. We have analyzed how the performance of a CMT processor is affected by contention for the processor pipeline, the L1 data cache, and the L2 cache, and have investigated operating system approaches to the management of these performance-critical resources. Having found that contention for the L2 cache can have the greatest negative impact on processor performance, we have quantified the potential performance improvement that can be achieved from L2-aware OS scheduling. We evaluated a scheduling policy based on the balance-set principle and found that it has a potential to reduce miss ratios in the L2 by 19-37% and improve processor throughput by 27-45%. To achieve a similar improvement in hardware requires doubling the size of the L2 cache.