Adrian Schüpbach

ETH Zurich, Zürich, Zurich, Switzerland

Are you Adrian Schüpbach?

Claim your profile

Publications (11)0 Total impact

  • Gerd Zellweger, Adrian Schüpbach, Timothy Roscoe
    [Show abstract] [Hide abstract]
    ABSTRACT: In this paper, we argue that an operating system structured as a distributed system needs a coordination and a name service to make OS services work correctly. While a distributed structure allows applying algorithms from the distributed field, it also suffers from similar problems like synchronization, naming, distributed locking and coordination of service instances. Octopus, our solution to this problem in the context of a real OS, provides an easy-to-use, high-level, uniform coordination service with events at reasonable performance. Based on this service, we describe three real use cases: device management, OS service registry and boot-up coordination.
    01/2012;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: C remains the language of choice for hardware programming (device drivers, bus configuration, etc.): it is fast, allows low-level access, and is trusted by OS developers. However, the algorithms required to configure and reconfigure hardware devices and interconnects are becoming more complex and diverse, with the added burden of legacy support, quirks, and hardware bugs to work around. Even programming PCI bridges in a modern PC is a surprisingly complex problem, and is getting worse as new functionality such as hotplug appears. Existing approaches use relatively simple algorithms, hard-coded in C and closely coupled with low-level register access code, generally leading to suboptimal configurations. We investigate the merits and drawbacks of a new approach: separating hardware configuration logic (algorithms to determine configuration parameter values) from mechanism (programming device registers). The latter we keep in C, and the former we encode in a declarative programming language with constraint-satisfaction extensions. As a test case, we have implemented full PCI configuration, resource allocation, and interrupt assignment in the Barrelfish research operating system, using a concise expression of efficient algorithms in constraint logic programming. We show that the approach is tractable, and can successfully configure a wide range of PCs with competitive runtime cost. Moreover, it requires about half the code of the C-based approach in Linux while offering considerably more functionality. Additionally it easily accommodates adaptations such as hotplug, fixed regions, and quirks.
    Proceedings of the 16th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2011, Newport Beach, CA, USA, March 5-11, 2011; 03/2011
  • Source
    3rd Many-core Applications Research Community (MARC) Symposium. Proceedings of the 3rd MARC Symposium, Ettlingen, Germany, July 5-6, 2011; 01/2011
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: As personal computing devices become increasingly parallel multiprocessors, the requirements for operating system schedulers change considerably. Future general-purpose machines will need to handle a dynamic, bursty, and interactive mix of parallel programs sharing a heterogeneous multicore machine. We argue that a key challenge for such machines is rethinking scheduling as an end-to-end problem integrating components from the hardware and kernel up to the programming language runtimes and applications themselves. We present several design principles for future OS schedulers, and discuss the implications of each for OS and runtime interfaces and structure. We illustrate the implementation challenges that result by describing the concrete choices we have made in the Barrelfish multikernel. This allows us to present one coherent scheduling design for an entire multicore machine, while at the same time drawing conclusions we think are applicable to the design of any general-purpose multicore OS.
    01/2010;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Abstract The future manycore architectures present serious challenges to operating sys- tem designers. The traditional operating system designs can no longer manage the capabilities and power of the diverse heterogeneous cores with complex memory hierarchies, interconnects resembling networks, and distributed I/O configurations. The Barrelfish multikernel operating system addresses these is- sues by treating hardware as a distributed system. Co-operation in such an environment is achieved by message passing. We borrow similar design ideas in this thesis and present a distributed USB hot plugging infrastructure for a multikernel Barrelfish operating system. We have divided the USB system into three primary modules with different responsibilities: Host controller driver, USB manager and client drivers. This modular design provides necessary iso- lation and flexibility required in manycore systems. It also provides freedom to schedule and, if required, migrate any module independently among the cores depending upon the system workload and the application requirements. These modules communicate by explicit message passing but a few frequently updated and performance critical data structures are shared using shared memory,mech- anism. In this thesis, we try to design, implement and evaluate this system on top of message services and abstractions provided by the Barrelfish operating system. iv Acknowledgments
    09/2009;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: For over forty years, we have assumed hierarchical file system namespaces. These namespaces were a rudimentary attempt at simple organization. As users have begun to interact with increasing amounts of data and are increasingly demanding search capability, ...
    Proceedings of HotOS'09: 12th Workshop on Hot Topics in Operating Systems, May 18-20, 2009, Monte Verità, Switzerland; 01/2009
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Commodity computer systems contain more and more processor cores and exhibit increasingly diverse architectural tradeo s, in- cluding memory hierarchies, interconnects, instruction sets and variants, and IO configurations. Previous high-performance com- puting systems have scaled in specific cases, but the dynamic nature of modern client and server workloads, coupled with the impossi- bility of statically optimizing an OS for all workloads and hardware variants pose serious challenges for operating system structures. We argue that the challenge of future multicore hardware is best met by embracing the networked nature of the machine, rethinking OS architecture using ideas from distributed systems. We investi- gate a new OS structure, themultikernel, that treats the machine as a network of independent cores, assumes no inter-core sharing at the lowest level, and moves traditional OS functionality to a distributed system of processes that communicate via message-passing. We have implemented a multikernel OS to show that the ap- proach is promising, and we describe how traditional scalability problems for operating systems (such as memory management) can be e ectively recast using messages and can exploit insights from distributed systems and networking. An evaluation of our prototype on multicore systems shows that, even on present-day machines, the performance of a multikernel is comparable with a conventional OS, and can scale better to support future hardware.
    Proceedings of the 22nd ACM Symposium on Operating Systems Principles 2009, SOSP 2009, Big Sky, Montana, USA, October 11-14, 2009; 01/2009
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: The trend towards cloud and utility computing infrastructures raises challenges not only for application development, but also for management: diverse resources, changing resource availability, and differing application requirements create a complex optimization problem. Most existing cloud applications are managed externally, and this separation can lead to increased response time to failures, and slower or less appropriate adaptation to resource availability and pricing changes. In this paper, we explore a different approach more akin to P2P systems: we closely couple a decentralized management runtime ("Rhizoma") with the application itself. The application expresses its resource requirements to the runtime as a constrained optimization problem. Rhizoma then fuses multiple real-time sources of resource availability data, from which it decides to acquire or release resources (such as virtual machines), redeploying the system to continually maximize its utility. Using PlanetLab as a challenging "proving ground" for cloud-based services, we present results showing Rhizoma's performance, overhead, and efficiency versus existing approaches, as well the system's ability to react to unexpected large-scale changes in resource availability.
    Middleware 2009, ACM/IFIP/USENIX, 10th International Middleware Conference, Urbana, IL, USA, November 30 - December 4, 2009. Proceedings; 01/2009
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Trends in multicore processors pose serious structural challenges to system software such as databases and operating systems. In this paper we revisit the decades-old problem of the interaction be-tween a database and an operating system in the new context of the changes imposed on both by multicore architectures. Using existing prototypes of a multicore database and multicore operat-ing system, we explore how they can efficiently interact so that the database can make optimal placement and deployment decisions without knowledge of the machine architecture. Our results show superior memory and interconnect utilization, and dramatic perfor-mance improvements in the presence of competing system tasks.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: We discuss diversity and heterogeneity in manycore computer systems, and identify three distinct types of diversity, all of which present challenges to operating system designers and application writers alike. We observe that most current research work has concentrated on a narrow form of one of these (non-uniform memory access) to the exclusion of the others, and show with measurement why this makes sense in the short term. However, we claim that this is not viable in the long term given current processor and system roadmaps, and present our approach to dealing with both heterogeneous hardware within a single system, and the increasing diversity of complete system configurations: we directly represent detailed system information in an expressive "system knowledge base" accessible to applications and OS subsystems alike, and use this to control tasks such as scheduling and resource allocation.
  • Source