Keyword: architecture, operating
system
Abstract: In an article by M.
Hayter and D. McAuley (see ibid., vol. 25, p.14-21, Oct. 1991), it was argued
that future high-performance systems trade a traditional, bus-based
organization for one where all components are linked together by network
switches (the Desk-Area Network). The authors conclude that DAN-based
architectures allow the exploitation of shared memory on a wider scale than
just a single (multi)processor. They explore how emerging 64-bit processors
can be used to implement shared address spaces spanning multiple machines.
Keyword: large address space,
operating system, distributed system, shared memory, desk-area network
Abstract: Shared virtual memory
(SVM) is a virtual memory layer with a single address space on top of a
distributed real memory on parallel computers. The article examines the
behavior and performance of SVM running a parallel program with loop-level
parallelism on top of it. A simulator for the underlying parallel
architecture can be used to examine the behavior of SVM more deeply. The
influence of several parameters, such as the number of processors, page size,
cold or warm start, and restricted page replication, is studied.
Keyword: large address space,
MONADS
Abstract: The authors describe
the integration of transactions into a computer architecture with a
persistent uniform virtual memory based on pages and combined with arbitrary
long segments. The ultimate goal is to offer implicit synchronisation of
parallel processes and recovery from a wide range of possible errors to a
large number of different applications, including the operating system,
without sacrificing the efficiency or the degree of parallelism. For this
reason it is proposed to implement transaction management at the
architectural level.
Abstract: The authors are
building an operating system called Opal for wide-address architectures. The
key feature of Opal is a single global virtual address space that extends to
data on long-term storage and across the network. The authors outline their
ideas for extending Opal to a distributed environment, focusing on the naming
and binding of data and services to allow uniform treatment across the
network. The central point is that although the meaning of names should be
uniform throughout the network, at a lower level the binding of names to
physical data or servers may vary with the node uttering the name, in order
to accommodate caching, replication, and migration. This principle affects
Opal's handling of both data names (virtual addresses) and resource names
(capabilities).
Keyword: distributed computing,
virtual memory, distributed shared memory, large address space
Abstract: Object-oriented
models are a popular basis for supporting uniform sharing of data and
services in operating systems, distributed programming systems, and database
systems. One terms systems that use objects for these purposes: object
sharing systems. Operating systems in common use have nonuniform addressing
models, making the uniform object naming required by object sharing systems
expensive and difficult to implement. It is argued that emerging 64-bit
architectures make it practical to support uniform naming at the virtual
addressing level, eliminating a key implementation problem for object sharing
systems. The authors describe facilities for object-based sharing of
persistent data and services in Opal, an operating system been developed for
paged 64-bit architectures. The distinctive feature of Opal is that object
sharing is supported in a runtime library, above a single virtual address
space that maps all primary and secondary storage in a l
Abstract: Most operating
systems execute programs in private address spaces communicating through
messages or files. The traditional private address space model was developed
for 16- and 32-bit architectures, on which virtual addresses are a scarce
resource. The recent appearance of architectures with flat 64-bit virtual
addressing opens an opportunity to reconsider our use of virtual address
spaces. In this paper we argue for an alternative addressing model, in which
all programs and data reside in a single global virtual address space shared
by multiple protection domains. Hardware-base memory protection exists within
the single address space, providing firewalls as strong as in conventional
systems. We explore the tradeoffs in the use of a global virtual address
space relative to the private address space model. We contend that a shared
address space can eliminate obstacles to efficient sharing and exchange of
data structures that are inherent in privat
Keyword: shared memory,
operating system, mapped files, large address space, Opal
Keyword: single address space
operating system
Keyword: verify, SASOS, large
address space, virtual memory, operating system, shared memory
Abstract: The availability of
large main memories and the emergence of new application domains make current
techniques of database buffer management inadequate. To overcome this, we
propose the use of the Virtual Memory Database (VMDB) approach for building
large database systems. The VMDB paradigm is based on the principle of
directly mapping a database into a vir- tual memory address space and
exploiting the buffer management facilities of the underlying virtual memory
system. We argue that for many application domains, the VMDB approach is
preferable to traditional techniques. However, the lack of appropriate and
efficient operating system support for recovery must first be addressed in
order to make the VMDB approach attrac- tive. To this end, we propose a
simple Recoverable- Persistent Updates model and develop a scheme for
ensuring that database pages in a VMDB system are propagated in an order and
manner that preserves recoverability and ensures per
Abstract: The buffering
facilities typically provided by operating systems are not powerful enough to
support the performance and consistency requirements of database systems. As
a result, most database systems are structured as Buffer Pool Database (BPDB)
systems, providing their own buffering facilities, with their own paging
policies and recovery schemes. The emergence of operating systems with very
large address spaces and flexible memory management makes Virtual Memory
Database (VMDB) systems feasible. In such systems, the database is mapped
into virtual memory and the buffering facilities of the underlying virtual
memory system are used. VMDB systems do not experience many of the problems
faced by BPDB systems. To support the consistency and recoverability
requirements of VMDB systems, we have proposed that the virtual memory system
be extended to support the Recoverable-Persistent Updates (RPU) model. This
model is powerful and general enough to sup
Abstract: The lack of suitable
buffering support in most operating systems for ensuring the performance and
consistency requirements of database applications has resulted in most
database systems providing their own buffering facilities. With the recent
emergence of new technologies and application domains that place new
requirements on buffering techniques, this approach is no longer adequate. An
attractive alternative is to improve the file memory-mapping facilities of
operating systems in order to allow database systems to exploit them by
directly map their databases into virtual memory [5,10] without compromising
performance and consistency requirements. In particular, to fully realize all
the benefits of this memory-mapped buffering approach, support for the
consistency and recoverability requirements of database systems needs to be
provided. In this paper, we propose that operating systems be extended to
support Recoverable-Persistent Virtual Memory
Abstract: The Intel
architecture for the 80*86 series machines lends itself well to the
implementation of persistent object oriented languages. They are also by a
wide margin the most commonly used CPUs in the world. Mass production has
driven down the costs of machines using these processors and they thus make
an appealing platform for experimentation. They have a model of store which
corresponds well to the 7 layer model of persistent memory proposed by the
authors: with physical, paged and segmented memory interfaces. One could map
persistent objects directly onto Intel segments, but this would suffer from
the small size of the segment identifier which only permits 16K of objects.
For a distributed object oriented system one needs a much larger number of
objects. The paper examines software and hardware techniques that can be used
to map dynamically from network wide object identifiers to hardware supported
segments. Four techniques are presented, two s
Abstract: Describes the
rationale for the design and the architecture of a Memory Management Unit
(MMU) for object-oriented systems. The CAMOES MMU supports arbitrary size
protected objects mapped on a single virtual address space. Support for
object invocations is provided in the form of an operations cache closely
coupled with the addressing hardware. The MMU only executes in hardware those
functions crucial for performance; other functions, namely the management of
internal buffers and associative memories, and object management policies,
are handled in software. This functional organisation is suitable for current
generation processors based on RISC principles and is able to support open
multi-lingual environments.
Keyword: MULTICS
Keyword: persistence,
addressing, stability, resilience, protection
Abstract: The authors describe
the basic design principles of a distributed operating system, MESS, which is
hardware independent in nature. MESS is based on the paradigm of global
address space, which replaces all the devices, including those reachable by
networks. The system, which runs on an arbitrarily large cluster of virtual
machines, will turn this cluster into a single processing server. Flexible
process migration, implemented as part of the virtual memory management
across the network, will hide completely the distributed nature of the
underlying hardware. The global virtual memory will be the primary means of
communication. The user will perceive the system as a single-machine
multitasking environment.
Abstract: The Mungi operating
system features a single 64 bit persistent address space encompassing all
data in the system. This differs dramatically from current generation
operating systems in which each process has its own address space and
persistent data is stored in a filesystem. This report is a preliminary
investigation of address space management issues raised by adopting a single
persistent address space model. Issues examined are internal and external
fragmentation of the address space, reuse versus no-reuse allocation
policies, and page table structures used to support the address space.
Abstract: We present the design
of a flexible architectural model that supports clustering, storing, naming,
and accessing objects in a large scale distributed system. The system is
logically divided in zones, i.e., groups of machines with an homogeneous
address space organization. Both uniform (64-bit) zone-wide and partitioned
(32 or 64-bit) address space organizations are supported. For Clustering
purpos objects are allocated within segments. Segments are logically grouped
into bunches. Each bunch has a usser-level bunch manager implementing the
policies related to persistence and distribution specific to the bunch's
data: allocation, garbage collection, mapping and un-mapping, function
shipping or data shipping, shared data consistency, migration, etc. Objects
are referenced by maillons and {SSP} (stub-scion pair) chains. THese
mechanisms are scalable and are well adapted to support distributed garbage
collection, migration and compaction.
Abstract: As an alternative to
communication via messages or files, shared memory has the potential to be
simpler, faster, and less wasteful of space. Unfortunately, the mechanisms
available for sharing in most multi-user operating systems are difficult to
use. As a result, shared memory tends to appear primarily in self-contained
parallel applications, where library or compiler support can take care of the
messy details. We see a tremendous opportunity to extend the advantages of
sharing across application boundaries. We believe that these advantages can
be realized without introducing major changes to the Unix programming model.
In particular, we believe that it is both possible and desirable to
incorporate shared memory segments into the hierarchical file system name
space. Our approach has two components: First, we use dynamic linking to
allow programs to access shared data and code in the same way they access
ordinary (private) variables and function
Keyword: shared memory,
operating system, mapped files, large address space
Abstract: Increased computer
throughput can be achieved through the use of parallel processing. The
granularity of a parallel program is the average number of instructions
performed by the tasks constituting it. Coarse-grained programs typically
execute huge numbers of instructions per task (~1,000,000). The tasks in
fine-grained programs are typically short (~10,000). In general, the finer
the program grain, the greater the potential for exploiting parallelism.
Amdahl's Law shows that in the absence of overheads, the more potential
parallelism that is realised in an algorith, the faster it will be. The
economical granularity of tasks is determined by the intertask communications
overhead. Break-even occurs when processing is approximately equally divided
between useful work and overhead. The two common parallel programming
paradigms are shared variable and message passing. Shared variable is, in
general, the more natural of the two as it allows implicit c
Abstract: With the development
of 64-bit microprocessors, it is now possible to combine local, secondary and
remote storage into a large single address-space. This results in a uniform
method for naming and accessing objects regardless of their location, removes
the distinction between persistent and transient data, and simplifies the
migration of data and processes. This paper describes the Mungi single
address-space operating system. Mungi provides a distributed single level
address-space, which is protected using password capabilities. The protection
system performs efficiently on conventional architectures, and is simple
enough that most programs do not need to be aware of its operation.
Keyword: shared memory,
distributed system, operating system, virtual memory, persistence, large
address space
Keyword: shared memory,
distributed system, operating system, virtual memory, persistence, large
address space
Keyword: persistence,
addressing, stability, resilience, protection
Abstract: The MONADS-PC
computer system implements an architecture supporting a very large persistent
store based on a uniform virtual memory. The authors have previously shown
how this virtual memory scheme can be extended to encompass a local area
network of MONADS-PC computers. In this paper they examine the question of
the integrity of the store in such a network. A modification to the MONADS
architecture to implement stability is reviewed and extended to guarantee
stability of a network-wide persistent store. The stability scheme allows for
temporary interruption to the physical network without affecting the validity
of exported pages owned by a node.
Keyword: MONADS, stability
Abstract: Persistent
programming in conventional systems indispensably involves pointer
conversion, which requires language-level support and causes heavy run-time
overheads. This paper presents the design of language-independent persistent
programming layer of the Lucas operating system, which enables user processes
to share, transfer, and copy persistent data structures, possibly containing
hardware-supported pointers, without pointer conversion. Assuming wide
address spaces of 64-bit processors, Lucas introduces regions and
inter-region references as two fundamental abstractions to manage
location-dependent persistent data structures. Lucas has been implementing on
DECstations running Mach 3.0 microkernels, and fundamental services have
already been functional.
Abstract: The MONADS computer
architecture is based on a very large persistent virtual memory which
eliminates the need for a conventional file store and filing system, thus
providing a suitable basis for persistent programming. The architecture also
provides direct support for persistent objects (modules), which are protected
by capabilities, and for processes which persist not only between login
sessions but also over system shutdowns. The authors briefly outline these
aspects of the architecture and describe how they are used in the design of
the MONADS operating system. They then show how these features naturally give
rise to a wide range of security advantages which would be very difficult to
achieve in conventional systems. They first discuss the security advantages
of persistent protected modules and then they consider how persistent
processes are organised, how they relate to modules and how they contribute
to stronger security. Next they describe
Keyword: MONADS
Keyword: virtual memory,
architecture, operating system, large address space
Abstract: Focuses on the
architectural implications of single address space operating systems,
specifically the interaction between the memory system architecture and the
operating system's use of addressing and protection. The purpose is to
explore certain architectural opportunities created by single address space
systems by evaluating two protection models that support them. The first
provides protection on a per-page, per-domain basis; the paper defines the
protection lookaside buffer, a hardware structure that implements this model.
The second provides protection on a page-group basis; this model is
implemented in the Hewlett-Packard PA-RISC architecture.
Keyword: single address space,
protection
Abstract: Trends toward
shared-memory programming paradigms, large (64-bit) address spaces, and
memory-mapped files have led some to propose the use of a single
virtual-address space, shared by all processes and processors. Typical
proposals require the single address space to contain all process-private
data, shared data, and stored files. To simplify management of an address
space where stale pointers make it difficult to re-use addresses, some have
claimed that a 64-bit address space is sufficiently large that there is no
need to ever re-use addresses. Unfortunately, there has been no data to
either support or refute these claims, or to aid in the design of appropriate
address-space management policies. In this paper, we present the results of
extensive kernel-level tracing of the workstations in our department, and
discuss the implications for single-address-space operating systems. We found
that single-address-space systems will not outgrow the availa
Keyword: operating system, wide
address space, virtual memory, memory management, dfk
Abstract: Trends toward
shared-memory programming paradigms, large (64-bit) address spaces, and
memory-mapped files have led some to propose the use of a single
virtual-address space, shared by all processes and processors. Typical
proposals require the single address space to contain all process-private
data, shared data, and stored files. To simplify management of an address
space where stale pointers make it difficult to re-use addresses, some have
claimed that a 64-bit address space is sufficiently large that there is no
need to ever re-use addresses. Unfortunately, there has been no data to
either support or refute these claims, or to aid in the design of appropriate
address-space management policies. In this paper, we present the results of
extensive kernel-level tracing of the workstations in our department, and
discuss the implications for single-address-space operating systems. We found
that single-address-space systems will not outgrow the availa
Keyword: operating system, wide
address space, virtual memory, memory management, dfk
Abstract: Surveys recent and
ongoing work at the University of Washington concerned with system support
for high performance multiprocessing. Three principal areas are addressed.
The first is the appropriate division of labor between the kernel and the
user-level on shared memory multiprocessors. The thesis is that significant
improvements in performance and flexibility can be achieved by moving
functionality out of the kernel. The second is support for sharing on
wide-address machines. Here the thesis is that addressability and protection
are orthogonal, and that with enough addressing bits and the right operating
system design, it is possible to have an efficient and safe single-address
space system that encourages flexible sharing. The third are addressed is
parallel/distributed computing. The goal is to build scalable high
performance systems out of 'commodity parts'. The obstacles include devising
a suitable programming model, and achieving low latenc
Keyword: garbage collection
Abstract: This paper describes
the architecture of the {IBM} {RISC} System/6000 and the {IBM} {AS/400} from
the standpoint of their suitability for implementing Persistent Object
Systems. Both systems provide facilities in their hardware, microcode and
operating system that, carefully used, can simplify the implementation of
Persistent Object Systems and improve their performance. The facilities
provided are not, however, perfectly matched to the requirements of
Persistent Object Systems. We discuss design trade-offs and identify
recommended extensions.
Abstract: Today's most popular
computers are built around 32-bit microprocessors. The next generation of
chips-64-bit microprocessors-will bring even more power to the desktop. There
are two reasons for the prediction: 64-bit integer processing and convenient
use of more than 32 bits of address space. The first reason is a
straightforward performance issue; the second has more widespread
implications. Applications for 64-bit microprocessors exist for both servers
and desktops.
Keyword: architecture, large
address space
Abstract: In the mid eighties,
the System Architecture Research Centre at City University developed a
message-passing, UNIX compliant micro kernel (Meshix) for our own scalable
distributed memory architecture (Topsy). Over the last two years we have been
engaged in a research programme aimed at learning from this experience, and
developing a new operating system based on these lessons. The result is the
Angel microkernel. This paper sets out the lessons we have learnt from
Meshix, how this has influenced the design of Angel and outlines our current
design of Angel and its C++ implementation. We will also describe our hopes
for Angel, and the lessons that we have learnt from the design and
implementation process.
Keyword: microkernels, large
address spaces, object oriented, operating system, shared memory
Abstract: A major problem with
programming systems such as distributed memory multicomputers or networks of
workstations has been the necessity for explicit, time-consuming and
expensive message passing. Distributed shared memory enables such systems to
appear to have a common memory though they may not physically share it. The
Systems Architecture Research Centre at City University has worked on
implementations of these kinds of systems and is experienced in the kinds of
benefits they can offer. These are outlined for applications to fault
tolerance. A DSM server implementation and its use are described. A method
for using hardware to assist distributed shared memory is also described.
Finally, a new architecture the Centre is studying is detailed.
Abstract: The appearance of
64-bit processors allows a new approach to microkernel design --- a single
unified address space. This paper describes this kind of approach as adopted
in Angel. [...]
Abstract: The authors made the
best use of the huge address space provided by a 64-bit next generation
architecture. A new micro kernel was designed with two outstanding features;
single virtual space and one level storage. Three major benefits from the
proposed kernel are fast context switching, fast function call, and fast data
access. This micro kernel manages only two abstractions to simplify the
concept; the thread and the memory section. The problem regarding how to
prevent access by unauthorized threads or programs which first occurred due
to the single virtual space has been finally solved with newly designed
rich-functioned MMU hardware.
Abstract: As the bandwidth
available via local, national and international networks increases, the uses
to which it can be put are also increasing. The current communications model,
where data is treated as a serial stream, makes poor use of these networks
because it assumes the delay due to limited bandwidth dominates the transfer
time. This is no longer the case. A different communications model is
therefore required to better utilise high -bandwidth networks. Network shared
memory provide two distinct benefits. Firstly, it provides a simpler, more
flexible communications model. Secondly, it allows the use of intelligent
caching to hide the latency of data access from the application. The research
programme described in this paper is aimed at developing the principles of
Network Shared Memory and realising a system which provides the benefits
noted above. In doing so, it uses a model of data exchange and sharing based
on random access rather than serial
Abstract: The availability of
64-bit processors enables the use of the shared address space (SAS) model
where all processes execute in the same address space. This is in contrast to
most existing operating systems that use the private address space (PAS)
model where each process views the entire space as dedicated to itself. The
PAS model can only support a restricted number of computational paradigms,
whereas the SAS model can provide general, efficient, flexible and simple
mechanisms to support various computational paradigms. Furthermore, the use
of the SAS model results in increased system performance. The SAS paradigm
can be classified into various models, which differ in the way the address
space and protection domain are managed. The different models yield different
computation domains and different performances. In this paper, we define a
new SAS model---the shared virtual address space (SVAS) model, and argue that
it is preferable over other exist
Abstract: The availability of
64-bit processors enables operating systems the use of the shared address
space (SAS) paradigm where all processes execute in the same address space.
This is in contrast to most existing operating systems that use the private
address space (PAS) paradigm where each process views the entire space as
dedicated to itself. The PAS paradigm yields high overhead for interprocess
communication and sharing, whereas the SAS paradigm can reduce the cost of
communication and provide simple abstractions to the application level to
build variety of communication schemes. Furthermore, the use of the SAS
paradigm results in increased system performance. The SAS paradigm can be
classified into various models, which differ in the way the address space and
protection domain are managed. In this paper, we provide a taxonomy of the
SAS models and discuss the tradeoffs between these models.
Keyword: large address space
system, shared address space paradigm, private address space paradigm, 64-bit
processors, address space management, protection domain management
Abstract: A capability-based
tightly coupled multiprocessor has been designed and constructed. The system
supports a persistent global virtual memory in which objects representing
processes, data and mechanisms for input/output reside. The hardware
architecture of the machine and its addressing mechanisms are described.
Addressing mechanisms that allow the persistent, global virtual memory to
span multiprocessor boundaries and the support required for operation over
wide area networks are discussed. The utility of uniform virtual addressing
is emphasized, and its implementation in the Monash multiprocessor is
described. The concept of an intermediate address space is introduced and its
applicability to the implementation of a persistent, global virtual-memory
architecture in a multiprocessor environment is demonstrated.
Abstract: Systems supporting
orthogonal persistence require a persistent store in which to maintain the
persistent objects. Such a persistent store can be implemented via an
extended virtual memory with addresses large enough to address all objects.
Superimposing structure and a protection scheme on these addresses may well
result in them being sparsely distributed. An additional incentive for
supporting large virtual addresses is an interest in exploiting the potential
of very large main memories to achieve supercomputer speed. The paper
presents hardware and software mechanisms to implement a paged virtual memory
which can be efficiently accessed by large addresses. An implementation of
these techniques for a capability-based computer, MONADS-PC, is described.
Keyword: virtual memory, large
address space
Abstract: Persistent systems
support mechanisms which allow programs to create and manipulate arbitrary
data structures which outlive the execution of the program which created
them. A persistent store supports mechanisms for the storage and retrieval of
objects in a uniform manner regardless of their lifetime. Since all data of
the system is in this repository it is important that it always be in a
consistent state. This property is called integrity. The integrity of the
persistent store depends in part on the store being resilient to failures.
That is, when an error occurs the store can recover to a previously recorded
consistent state. The mechanism for recording this state and performing
recovery is called stability. This paper considers an implementation of a
persistent store based on a large virtual memory and shows how stability is
achieved.
Abstract: ...Our GVM system
uses conventional computing nodes conected to specialised network interfaces.
A fault-tolerant migration and replication protocol keeps the system
operational and consistent in case of network errors or node crashes.
Password capabilities are used to control access to the GVM.
Abstract: Shared memory as a
programming abstraction is widely used within parallel applications. It is
not widely used between applications, but we argue that it should be.
Specifically, we suggest that shared memory is both faster and more intuitive
than the principal alternatives in many cases, and that the general disuse of
shared memory facilities in systems such as Unix is due in large part to a
lack of appropriate tools. We are pursuing a series of measures to make
shared memory more convenient. We use dynamic linking to allow programs to
access shared or persistent data the same way they access ordinary variables
and functions. We also unify memory and files into a single-level store that
facilitates the sharing of pointers and capitalizes on emerging 64-bit
architectures. We exploit existing interfaces and tools wherever possible, to
remain backward-compatible with Unix.
Keyword: operating system,
virtual memory, NUMA
Keyword: operating system,
virtual memory, NUMA
Keyword: operating system,
virtual memory, NUMA
Abstract: A persistent memory
system provides a storage architecture for long-term, reliable retention of
objects with rich types and structures in the virtual memory itself. It is
based on a uniform memory abstraction, which eliminates the distinction
between transient objects (data structures) and persistent objects (files and
databases) and therefore allows the same set of powerful and flexible
operations to be applied with equal efficiency on both transient and
persistent objects from a programming language such as Lisp or Prolog.
Because no separate file system is assumed for long-term, reliable storage of
objects, the system requires a crash recovery scheme at the level of the
virtual memory. The author provides this and feels that it is a major
contribution.
Abstract: Sharing global remote
data over large networks poses two major problems: firstly, the data must be
discovered; and secondly, the data must be made accessible to the
application. Our aim is to provide a single unified interface to both local
and remote data, removing location dependence and improving performance. Our
solution incorporates shared memory and caching techniques. A location server
provides a location transparent addressing scheme which is used to provide
failure tolerant retrieval. Access is provided via the ``native'' system
interfaces.
Abstract: Eric Koldinger and
others at the University of Washington Department of Computer Science have
proposed a new model for memory protection in single-address-space
architectures. The paper compares the Washington proposal with what already
exists in PA-RISC, and suggests some incremental improvements to the latter
that would provide most of the benefits of the former.
Keyword: protection, memory
management, large address spaces, architecture
Abstract: We describe an
operating system design for multiprocessor systems called ANGEL, based on a
single, coherent, uniform virtual address space. This unifies naming and
interprocess communication in both shared and distributed memory
multiprocessors by using distributed shared memory techniques when shared
memory is not provided by the hardware. The design is motivated by analysis
of our earlier operating system implementation, based on message passing, and
we show how the uniform address space attempts to solve problems with that
approach. In particular, we consider the use of client-server cross-mapping
to optimise interprocess communications, as used in Bershad et al.'s
lightweight RPC. This document describes initial motivations for ANGEL and
subsequent detailed design---we will review and may modify many of the
details described as the design progresses.
Keyword: microkernels, large
address spaces, object oriented, operating system, shared memory
Abstract: This paper examines
techniques to enable standard UNIX applications to be executed on a new
single address space operating system, \Angel. This is achieved using
advanced compiler techniques which allows multiple execution of the same
program without conflicts and will also produce forkable code. The operating
system is briefly examined and the compiler changes described in detail.
Results are then presented which demonstate such techniques do not adversly
effect application performance.
Abstract: This thesis explores
the potential of 64-bit processors for providing a different style of
distributed operating system. Rather than providing another reworking of the
UNIX model, the use of the large address space for unifying volatile memory
(virtual memory), persistent memory (file systems) and distributed network
access is examined and a novel operating system, Arius, is proposed. The
concepts behind the design of Arius are briefly reviewed, and then the
reliability of such a system is examined in detail. The unified nature of the
architecture makes it possible to use a reliable single address space to
provide a completely reliable system without the addition of other
mechanisms. Protocols are proposed to provide locally scalable distributed
shared memory and these are then augmented to handle machine failures
transparently though the use of distributed checkpoints and rollback. The
checkpointing system makes use of the caching mechanism in D
Abstract: Describes a scheme
for supporting huge address spaces without the need for long addresses
implemented in hardware. Pointers are translated ('swizzled') from a long
format to a shorter format (directly supported by normal hardware) at page
fault time. No extra hardware is required beyond that normally used by
virtual memory systems, and no continual software cost is incurred by
presence checks or indirection of pointers. This scheme could be used to
fault pages into a normal memory from a persistent store, or simply to avoid
extra hardware requirements when supporting large address spaces. It exploits
temporal and spatial locality in much the same way as a normal virtual
memory, so its performance should be quite good.
Keyword: pointer swizzling