17886110
Using a single address space operating system for distributed computing and high performance
Recent 64-bit microprocessors have made a huge 18.4 quintillion byte address space potentially available to programs. This has led to the design of Operating Systems that provide a single virtual address space in which all code and data reside in and that spans all levels of storage and all nodes of a distributed system. These operating systems called SASOSs, have characteristics that can be used to support synchronization and coherency in a distributed system in ways that provide an improved program development environment and higher performance than that available from conventional operating systems. Sombrero, our SASOS design, makes use of its hardware support for object-grained protection, separate thread related protection domains and implicit protection domain crossing to provide synchronization and coherency support for distributed object copy set management not available in SASOSs built on stock processors. Its design, which provides direct system level support for object oriented programming includes a number of system architectural features targeted at modern distributed computing.
35435747
The Sombrero Single Address Space Operating System Prototype A Testbed for Evaluating Distributed Persistent System Concepts and Implementation
The Sombrero distributed single address space operating system prototype is currently being implemented. The prototype includes an emulation of CPU-resident protection hardware necessary to fully utilize the properties of a single address space. The primary objective of the Sombrero project is to demonstrate that software development costs are sharply reduced in a single address space environment with no reduction in performance. This paper presents Sombrero design decisions and implementation mechanisms developed in order to support protection, communication, resource access and control transfer across a very large persistent distributed address space. Included are changes to operating system architecture, evolution of programming types and a new approach to distributed consistency management in a single address space based-DSM system that is being integrated into the prototype.
1440056
Concerning the achromatic number of graphs
Abstract The achromatic number of a graph G is the largest number of colors that can be assigned to the vertices of G so that (i) adjacent vertices are assigned different colors, and (ii) any two different colors are assigned to some pair of adjacent vertices. We study the achromatic number from the point of view of computational complexity. We show that, for each fixed integer n , there is an algorithm which, for an arbitrary graph G , determines in time O (| E ( G )|) whether the achromatic number of G is at least n . In contrast to this, we show that when n is part of the input, the problem is NP-complete even when restricted to bipartite graphs. The complexity of determining the achromatic number of a tree is unknown. We present polynomial algorithms to solve this problem for several classes of trees, and provide upper bounds on the achromatic number of a tree in terms of the maximum degree and the number of edges.
3091178
Using Linear Logic to Reason about Sequent Systems
Linear logic can be used as a meta-logic for the specification of some sequent calculus proof systems. We explore in this paper properties of such linear logic specifications. We show that derivability of one proof system from another has a simple decision procedure that is implemented simply via bounded logic programming search. We also provide conditions to ensure that an encoded proof system has the cut-elimination property and show that this can be decided again by simple, bounded proof search algorithms.
10134130
A Congruence Format for Name-passing Calculi
We define and use a SOS-based framework to specify the transition systems of calculi with name-passing properties. This setting uses proof-theoretic tools to take care of some of the difficulties specific to name-binding and make them easier to handle in proofs. The contribution of this paper is the presentation of a format that ensures that open bisimilarity is a congruence for calculi specified within this framework, extending the well-known tyft/tyxt format to the case of name-binding and name-passing. We apply this result to the @p-calculus in both its late and early semantics.
5278164
A Logic Programming Approach to Manipulating Formulas and Programs
By permitting function and predicate symbols to be variables and by replacing first-order terms by simply typed $lambda$-terms, a higher-order extension to first-order Horn clauses can be described. To be complete in principle, a logic programming language based on this extension must incorporate higher-order unification. Although this is a more complex operation than first-order unification, its availability as a primitive makes certain kinds of programming tasks easier. We illustrate this aspect in the paper by presenting some programs in a higher-order version of Prolog called $\lambda$Prolog that manipulate objects, such as formulas and programs, whose representation requires structures containing abstractions or bound variables. Specifically, we show (a) how a simple natural deduction theorem prover may be implemented in $\lambda$Prolog, and (b) how some simple program transformers for a functional programming language may be written in this language. These programs exploit the availability of $\lambda$-conversion and higher-order unification in $\lambda$Prolog to provide elegant solutions to several awkward problems inherent in these tasks. We contend that programs which perform similar tasks but which are written in languages without these features would, at least, be much less perspicuous.
2713619
A proof theory for generic judgments
The operational semantics of a computation system is often presented as inference rules or, equivalently, as logical theories. Specifications can be made more declarative and high level if syntactic details concerning bound variables and substitutions are encoded directly into the logic using term-level abstractions (λ-abstraction) and proof-level abstractions (eigenvariables). When one wishes to use such logical theories to support reasoning about properties of computation, the usual quantifiers and proof-level abstractions do not seem adequate: proof-level abstraction of variables with scope over sequents (global scope) as well as over only formulas (local scope) seem required for many examples. We will present a sequent calculus that provides this local notion of proof-level abstraction via generic judgment and a new quantifier, ∇, which explicitly manipulates such local scope. Intuitionistic logic extended with ∇ satisfies cut-elimination even when the logic is additionally strengthened with a proof theoretic notion of definitions. The resulting logic can be used to encode naturally a number of examples involving abstractions, and we illustrate the uses of ∇ with the π-calculus and an encoding of provability of an object-logic.