LCS Technical Memos (1974 - 2003)

Enhanced Certificate Revocation

2023-03-30T15:18:53Z

Enhanced Certificate Revocation Micali, Silvio We apply off-line/on-line signatures to provide an alternative solution to the problem of certificate revocation. The new systems dismiss with traditional CRLs (Certificate Revocation Lists) and yield public-key infrastructures that are substantially cheaper to run than traditional ones.

What are principal typings and what are they good for?

2023-03-30T15:08:48Z

What are principal typings and what are they good for? Jim, Trevor We demonstrate the pragmatic value of the principal typing property, a property more general than ML's principal type property, by studying a type system with principal typings. The type system is based on rank 2 intersection types and is closely related to ML. Its principal typing property provides elegant support for separate compilation, including "smartest recompilation" and incremental type inference, and for accurate type error messages. Moreover, it motivates a novel rule for typing recursive definitions that can type many examples of polymorphic recursion.

Rank 2 Type Systems and Recursive Definitions

2023-03-30T14:57:19Z

Rank 2 Type Systems and Recursive Definitions Jim, Trevor We demonstrate an equivalence between the rank 2 fragments of the polymorphic lambda calculus (System F) and the intersection type discipline: exactly the same terms are typable in each system. An immediate consequence is that typability in the rank 2 intersection system is DEXPTIME-complete. We introduce a rank 2 system combining intersections and polymorphism and prove that it types exactly the same terms as the other rank 2 systems. The combined system suggests a new rule for typing recursive definitions. The result is a rank 2 type system with decidable type inference that can type some interesting examples of polymorphic recursion. Finally, we discuss some applications of the type system in data representation optimizations such as unboxing and overloading.

An Autoimmune Mechanism for AIDS' T4 Lymphopenia

2023-03-30T14:52:29Z

An Autoimmune Mechanism for AIDS' T4 Lymphopenia Micali, Silvio We put forward a new model for the T4 lymphopenia occuring in AIDS by suggesting a mechanism whose net effect is blocking the generation of T4 cells during HIV infection. Supporting evidence for this mechanism is derived from the experiments in the recent literature.

Randomness-efficient Sampling of Arbitrary Functions

2023-03-30T14:24:38Z

Randomness-efficient Sampling of Arbitrary Functions Bellare, Mihir; Rompel, John

A Modular Drinking Philosophers Algorithm

2023-03-30T14:24:18Z

A Modular Drinking Philosophers Algorithm Welch, Jennifer Lundelius; Lynch, Nancy A. A variant of the drinking philosphers algorithm of Chandy and Misra is described and proved correct in a module way, using the I/O automaton model of Lynch and Tuttle. The algorithm of Chandy and Misra is based on an particular dining philosophers algorithm, and relies on certain properties of its implementation. The drinking philosophers algorithm presented in this paper is able to use an arbitrary dining philosophers algorithm as a true subroutine; nothing about the implementation needs to be known, only that is solves the dining philosophers problem. An important advantage of this modularity is that by substituting a more time-efficient dining philosophers algorithm with O(1) worst-case waiting time is obtained, whereas the drinking philosophers algorithm of Chandy and Misra has O(n) worst-case waiting time (for n philosophers). Formal definitions are given to distinguish the drinking and dining philosophers problems and to specify precisely varying degrees of concurrency.

Execution Model Enforcement Via Program Shepherding

2023-03-30T03:21:26Z

Execution Model Enforcement Via Program Shepherding Kiriansky, Vladimir; Bruening, Derek; Amarasinghe, Saman Nearly all security attacks have one thing in common: they coerce the target program into performing actions that it was never intended to perform. In short, they violate the program's execution model. The execution model encompasses the Application Binary Interface (ABI), higher-level specifications from the program's source programming language, and components specific to the program --- for example, which values a particular function pointer may take. If this execution model were enforced, and only program actions that the programmer intended were allowed, a majority of current security holes would be closed. In this paper, we employ program shepherding[26] to enforce a program's execution model. Program shepherding monitors control flow in order to enforce a security policy. We use static and dynamic analyses to automatically build a custom security policy for a target program which specifies the program's execution model. We have implemented our analyses in the DynamoRIO [5] runtime code modification system. The resulting system imposes minimal or no performance overhead, operates on unmodified native binaries, and requires no special hardware or operating system support. Our static analyses require source code access but not recompilation. The analysis process requires no user interaction, but is able to build a strict enough policy to prevent all deviations from the program's control flow graph and nearly all violations of the calling convention, greatly reducing the possibility of an unintended program action.

Scalable Packet Classification Using Bit Vector Aggregating and Folding

2023-03-30T04:06:26Z

Scalable Packet Classification Using Bit Vector Aggregating and Folding Li, Ji; Liu, Haiyang; Sollins, Karen Packet classification is a central function for a number of network applications, such as routing and firewalls. Most existing algorithms for packet classification scale poorly in either time or space when the database size grows. The scalable algorithm Aggregated Bit Vector (ABV) is an improvement on the Lucent bit vector scheme (BV), but has some limitations. Our algorithm, Aggregated and Folded Bit Vector (AFBV), seeks to reduce false matches while keeping the benefits of bit vector aggregation and avoiding rule rearrangement. It combines bit vector aggregation and folding to achieve this goal. Experiments showed that our algorithm outperforms both the BV and ABV schemes in synthetically generated databases.

Stream Algorithms and Architecture

2023-03-30T04:20:47Z

Stream Algorithms and Architecture Henry, Hoffman; Strumpen, Volker; Agarwal, Anant Wire-exposed, programmable microarchitectures including Trips [11]], Smart Memories [8], and Raw [13] offer an opportunity to schedule instruction execution and data movement explicitly. This paper proposes stream algorithms, which, along with a decoupled systolic architecture, provide an excellent match for the physical and technological constraints of single-chip tiles architectures. Stream algorithms enable programmed systolic computations for different problem sizes, without incurring the cost of memory accesses. To that end, we decouple memory accesses from computation and move the memory accesses off the critical path. By structuring computations in systolic phases, and deferring memory accesses to dedicated memory processors, stream algorithms can solve many regular problems with varying sizes on a constant-sized tiled array. Contrary to common sense, the compute efficiency of stream algorithms increases as we increase the number of processing elements. In particular, we show that the compute efficiency of stream algorithms can approach 100% asymptotically, that is for large numbers of processors and appropriate problem size.

A Theoretical and Practical Approach to Instruction Scheduling on Spatial Architectures

2023-03-30T04:06:57Z

A Theoretical and Practical Approach to Instruction Scheduling on Spatial Architectures Mirrokni, Vahab S.; Lee, Walter; Karger, David; Amarasinghe, Saman This paper studies the problem of instruction assignment and scheduling on spatial architectures. Spatial architectures are architectures whose resources are organized in clusters, with non-zero communication delays between the clusters. On these architectures, instruction scheduling include both space scheduling, where instructions are mapped to clusters, and the traditional time scheduling. This paper considers the problem from both the theoretical and practical perspectives. It presents two integer linear program formulations with known performance bounds. We also present an 8-approximation algorithm for constant m and constant communication delays. Then, we introduce three heuristic algorithms based on list scheduling. Then we study a layer partitioning method. Our final algorithm is a combination of layer partitioning and the third heuristic. Two of the better algorithms are evaluated on the Raw machine. Results show that they are competitive with previously published results; for scientfici codes, our heuristics can perform an average of 25% better.

pStore: A Secure Peer-to-Peer Backup System

2023-03-30T04:08:39Z

pStore: A Secure Peer-to-Peer Backup System Batten, Christopher; Barr, Kenneth; Saraf, Arvind; Trepetin, Stanley In an effort to combine research in peer-to-peer systems with techniques for incremental backup systems, we propose pStore: a secure distributed backup system based on an adaptive peer-to-peer network. pStore exploits unused personal hard drive space attached to the Internet to provide the distributed redundancy needed for reliable and effective data backup. Experiments on a 30 node network show that 95% of the files in a 13 MB dataset can be retrieved even when 7 of the nodes have failed. On top of this reliability, pStore includes support for file encryption, versioning, and secure sharing. Its custom versioning system permits arbitrary version retrieval similar to CVS. pStore provides this functionality at less than 10% of the network bandwidth and requires 85% less storage capacity than simpler local tape backup schemes for a representative workload.

Offline Authentication of Untrusted Storage

2023-03-30T03:03:52Z

Offline Authentication of Untrusted Storage Clarke, Dwaine; Gassend, Blaise; Suh, G. Edward; van Dijk, Marten; Devadas, Srinivas We extend the offline memory correctness checking scheme presented by Blum et. al [BEG+91], by using incremental cryptography, to detect attacks by an active adversary. We also introduce a hybrid o_ine-online checking scheme designed for untrusted storages in file systems and databases. Previous work [GSC+02] [FKM00] [MVS00] describe systems in which Merkle trees are used to verify the authenticity of data stored on untrusted storage. The Merkle trees [Mer79] are used to check, after each operation, whether the storage performed correctly. The offline and hybrid checkers are designed for checking sequences of operations on an untrusted storage and, in the common case, require only a constant overhead on the number of accesses to the storage, as compared to the logarithmic overhead incurred by online Merkle tree schemes

Phased Computation Graphs in the Polyhedral Model

2023-03-30T03:04:49Z

Phased Computation Graphs in the Polyhedral Model Thies, William; Lin, Jasper; Amarasinghe, Saman We present a translation scheme that allows a broad class of dataflow graphs to be considered under the optimization framework of the polyhedral model. The input to our analysis is a Phased Computation Graph, which we define as a generalization of the most widely used dataflow representations, including synchronous dataflow, cyclo-static dataflow, and computation graphs. The output of our analysis is a System of Affine Recurrence Equations (SARE) that exactly captures the data dependencies between the nodes of the original graph. Using the SARE representation, one can apply many techniques from the scientific community that are new to the DSP domain. For example, we propose simple optimizations such as node splitting, decimation propagation, and stead-state invariant code motion that leverage the fine-grained dependence information of the SARE to perform novel transformations on a stream graph. We also propose ways in which the polyhedral model can offer new approaches to classic problems of the DSP community, such as minimizing buffer size, code size, and optimizing the schedule.

A Collision Model for Randomized Routing In Fat-Tree Networks

2023-03-30T04:06:31Z

A Collision Model for Randomized Routing In Fat-Tree Networks Strumpen, Volker; Krishnamurthy, Arvind

How to Build Scalable On-Chip ILP Networks for a Decentralized Architecture

2023-03-30T03:33:00Z

How to Build Scalable On-Chip ILP Networks for a Decentralized Architecture Taylor, Michael Bedford; Lee, Walter; Frank, Matthew; Amarasinghe, Saman; Agarwal, Anant The era of billion transistors-on-a-chip is creating a completely different set of design constraints, forcing radically new microprocessor archiecture designs. This paper examines a few of the possible microarchitectures that are capable of obtaining scalable ILP performance. First, we observe that the network that interconnects the processing elements is the critical design point in the microarchitecture. Next, we characterize four fundamental properties that have to be satisfied by the interconnection network. Next, we provide case studies of two different networks that satisfy these properties. Finally, a detailed evaluation of these networks is presented to highlight the scalability and performance of these microarchitectures. We show that by using compile time information, we can build simpler networks and use them efficiently.

A Stream Compiler for Communication-Exposed Architectures

2023-03-30T03:49:11Z

A Stream Compiler for Communication-Exposed Architectures Gordon, Michael; Thies, William; Karczmarek, Michael; Wong, Jeremy; Hoffmann, Henry; Maze, David; Amarasinghe, Saman With the increasing miniturization of transistors, wire delays are becoming a dominant factor in microprocessor performance. To address this issue, a number of emerging architectures contain replicated processing units with software-exposed communication between one unit and another (e.g., Raw, iWarp, SmartMemories). However, for their use to be widespread, it will be necessary to develop compiler technology that enables a portable, high-level language to execute efficiently across a range of wire-exposed architectures. In this paper, we describe our compiler for StreamIt: a high-level, architecture-independent language for streaming applications. We focus on our backend for the Raw processor. Though StreamIt exposes the parallelism and communication patterns of stream programs, much analysis is needed to adapt a stream program to a parallel stream processor. We describe fission and fusion transformations that can be used to adjust the granularity of a stream graph, a layout algorithm for mapping a stream graph to a given network topology, and a scheduling algorithm for generating a fine-grained static communication pattern for each computational element. We have implemented a fully functional compiler that parallelizes StreamIt applications for Raw, including several load-balancing optimizations. Using the cycle-accurate Raw simulator, we demonstrate that these optimizations can improve performance by up to 145%. We consider this work to be a first step towards a portable programming model for communication-exposed architectures.

A Note on the Stability Requirements of Adaptive Virtual Queue

2023-03-30T03:36:29Z

A Note on the Stability Requirements of Adaptive Virtual Queue Katabi, Dina; Blake, Charles Choosing the correct value for the parameters of an Active Queue Management (AQM) scheme is a well-known hard problem. The Adaptive Virtual Queue (AVQ) attempts at solving this problem by using stability requirements to devise a rule for setting its parameter. This memo shows that the AVQ rule for setting its parameter is impractical for many real-life situations.

Secure Execution Via Program Shepherding

2023-03-30T03:23:10Z

Secure Execution Via Program Shepherding Kiriansky, Vladimir; Bruening, Derek; Amarasinghe, Saman We introduce program shepherding, a method for monitoring control flow transfers during program execution to enforce a security policy. Shepherding ensures that malicious code masquerading as data is never executed, thwarting a large class of security attacks. Shepherding can also enforce entry points as the only way to execute shared library code. Furthermore, shepherding guarantees that sandboxing checks around any type of program operation will never be bypassed. We have implemented these capabilities efficiently in a runtime system with minimal or no performance penalties. This system operates on unmodified native binaries, requires no special hardware or operating system support, and runs on existing IA-32 machines.

Efficient View-Dependent Sampling of Visual Hulls

2023-03-30T04:09:15Z

Efficient View-Dependent Sampling of Visual Hulls Matusik, Wojciech; Buehler, Chris; McMillan, Leonard In this paper we present an efficient algorithm for sampling visual hulls. Our algorithm computers exact points and normals on the surface of visual hull instead of a more traditional volumetric representation. The main feature that distinguishes our algorithm from previous ones is that it allows for sampling along arbitrary viewing rays with no loss of efficiency. Using this property, we adaptively sample visual hulls to minimize the number of samples needed to attain a given fidelity. In our experiments, the number of samples can typically be reduced by an order of magnitude, resulting in a corresponding performance increase over previous algorithms.

An Efficient Visual Hull Computation Algorithm

2023-03-30T03:09:23Z

An Efficient Visual Hull Computation Algorithm Matusik, Wojciech; Buehler, Chris; McMillan, Leonard; Gortler, Steven J. In this paper we describe an efficient algorithm for computing the visual hull of an object. This problem is equivalent to computing the intersection of generalized cones. The naïve visual hull computation algorithm requires intersecting 3D polyhedra. We exploit the special structure of generalized cone polyhedra and show how to reduce this computation to a set of intersections in 2D. Moreover, we describe how the 2D intersections can be carried out efficiently.

StreamIT: A Complier for Streaming Applications

2023-03-30T03:02:01Z

StreamIT: A Complier for Streaming Applications Thies, William F.; Karczmarek, Michael; Gordon, Michael; Maze, David; Wong, Jeremy; Hoffmann, Henry; Brown, Matthew; Amarasinghe, Saman Streaming programs represent an increasingly important and widespread class of applications that holds unprecedented opportunitie sfor high-impact compiler technology. Unlike sequential programs with obscured dependence information and complex communication patterns, a stream program is naturally written as a set of concurrent filters with regular steady-state communication. The StreamIt language aims to provide a natural, high-level syntax that improves programmer productivity in the streaming domain. At the same time, the language imposes a hierarchical structure on the stream graph that enables novel representations and optimizations within the StreamIt compiler. We define the "stream dependence function," a fundamental relationship between the input channels of two filters in a stream graph. We also describe a suite of stream optimizations, a denotational semantics for validating these optimizations, and a novel phased scheduling algorithm for stream graphs. In addition, we have implemented a prototype of the StreamIt optimizing compiler that is showing promising results.

Techniques for Increasing and Detecting Memory Alignment

2023-03-30T03:19:40Z

Techniques for Increasing and Detecting Memory Alignment Larsen, Samuel; Witchel, Emmett; Amarasinghe, Saman Memory alignment is an important property in memory system performance. Extraction of alignment information at compile-time enables the possibility for new classes of program optimization. In this paper, we present methods for increasing and detecting the alignment of memory references in a program. Our transformations and analyses do not require interprocedural analysis and introduce almost no overhead. As a result, they can be incorporated into real compilation systems. On average, our techniques are able to achieve a five-fold increase in the number of dynamically aligned memory references. We are then able to detect 94% of these operations. This success is invaluable in providing performance gains in a range of different areas. When alignment information is incorporated into a vectorizing compiler, we can increase the performance of a G4 AltiVec processor by more than a factor of two. Using the same methods, we are able to reduce energy consumption in a data cache by as much as 35%.

StreaMIT: A Language for Streaming Applications

2023-03-30T04:17:59Z

StreaMIT: A Language for Streaming Applications Thies, William F.; Karczmarek, Michael; Amarasinghe, Saman We characterize high-performance streaming applications as a new and distinct domain of programs that is becoming increasingly important. The StreaMIT language provides novel high-level representations to improve programmer productivity and program robustness within the streaming domain. At the same time, the StreaMIT compiler aims to improve the performance of streaming applications via stream-specific analyses and optimizations. In this paper, we motivate, describe and justify the language features of StreaMIT, which include: a structured model of streams, a messaging system for control, a re-initialization mechanism, and a natural textual syntax. We also present a means of reasoning about time in terms of "information flow": a concept that we believe is fundamental to the streaming domain. Using this concept, we give a formal semantics for StreaMIT's messaging system, as well as a simple algorithm for detecting deadlock and buffer overlow.

A Software Framework for Supporting General Purpose Applications on RAW Computation Fabrics

2023-03-30T03:52:56Z

A Software Framework for Supporting General Purpose Applications on RAW Computation Fabrics Frank, Matthew; Lee, Walter; Amarasinghe, Saman This paper presents SUDS (Software Un-Do Systems), a data speculation system for Raw processors. SUDS manages specultation in software. Thekey to managing speculation in software is to use the compiler to minimize the number of data items that need to be managed in runtime. Managing speculation in software enables Raw processors to achieve good performance on integer applications without sacrificing chip area for speculation hardware. This additional area can instead be devoted to additional computer resources, improving the performance of dense matrix and media applications.

Persona: A Contextualized and Personalized Web Search

2023-03-30T03:12:34Z

Persona: A Contextualized and Personalized Web Search Tanudjaja, Francisco; Mui, Lik Recent advances in graph-based search techniques derived from Kleinberg's work [1] have been impressive. This paper further improves the graph-based search algorithm in two dimensions. Firstly, variants of Kleinberg's techniques do not take into account the semantics of the query string nor of the nodes being searched. As a result, polysemy of query words cannot be resolved. This paper presents an interactive query scheme utilizing the simple web ontology provided by the Open Directory Project to resolve meanings of a user query. Secondly, we extend a recently proposed personalized version of the Kleinberg algorithm [3]. Simulation results are presented to illustrate the sensitivity of our technique. We outline the implementation of our algorithm in the Persona personalized web search system.

Ratings in Distributed Systems: A Bayesian Approach

2023-03-30T03:47:46Z

Ratings in Distributed Systems: A Bayesian Approach Mui, Lik; Mohtashemi, Mojdeh; Ang, Cheewee; Szolovits, Peter; Halberstadt, Ari For distributed systems at large and e-commerce systems in particular, ratings play an increasingly important role. Rating confer reputation measures about sources. This paper reports our formalization of the rating process. This paper argues that rating shuold be context- and individual- dependent quantities. In contrast to existing rating systems in many e-commerce or developer sites, our approach makes use of personalized and contextualized ratings for assessing source reputation. Our approach is based on a Bayesian probabilistic framework.

Three Round Zero-Knowledge Using a Proof of Knowledge Assumption

2023-03-30T04:23:55Z

Three Round Zero-Knowledge Using a Proof of Knowledge Assumption Lepinski, Matthew; Micali, Silvio We provide a proof of knowledge assumption that allows us to construct a three round zero-knowledge proof system for any language in NP.

Mutually Independent Commitment

2023-03-30T03:52:44Z

Mutually Independent Commitment Liskov, Moses; Lysyanskeya, Anna; Micali, Silvio; Reyzin, Leonid; Smith, Adam We describe a new kind of commitment scheme in which two parties commit to values in a commitment stage, at the end of which we are assured that the values they have committed to cannot be correlated to one another. We call this new primitive mutually independent commitments. We present three mutually independent commitment schemes which handle single bit commitments, and which are computationally hiding and perfecting binding.

Forward-Secure Signatures with Optimal Signing and Verifying

2023-03-30T03:02:42Z

Forward-Secure Signatures with Optimal Signing and Verifying Itkis, Gene; Reyzin, Leonid Ordinary digital signatures have an inherent weakness: if the secret key is leaked, then all signatures, even the ones generated before the leak, are no longer trustworthy. Forward-secure digital signatures were recently proposed to address this weakness: they ensure that past signatures remain secure even if the current secret key is leaked. We propose the first forward-secure signature scheme for which both signing and verifying are as efficient as for one of the most efficient ordinary signature schemes (Guillou-Quisquater): each requiring just two modular exponentiations with a short exponent. All previously proposed forward-secure signature schemes took significantly longer to sign and verify than ordinary signature schemees. Our scheme requires only fractional increases to the sizes of keys and signatures, and no additional public storage. Like the underlying Guillou-Quisquater scheme, our scheme is provably secure in the random oracle model.

A Unified Framework for Schedule and Storage Optimization

2023-03-30T04:16:02Z

A Unified Framework for Schedule and Storage Optimization Thies, William F.; Viven, Frederic; Sheldon, Jeffery W.; Amarasinghe, Saman We present a unified mathematical framework for analyzing the tradeoffs between parallelism and storage allocation within a parallelizing compiler. Using this framework, we show how to find the best storage mapping for a given schedule, the best schedule for a given storage mapping, and the best storage mapping that is valid for all legal schedules. Our techniques combines affine scheduling techniques with occupancy vector analysis, and incorporates general affine dependencies across statements and loop nests. We formulate the constraints imposed by the data dependencies and the storage mapping as a set of linear inequalities, and apply numerical programming techniques to efficiently solve for the best occupancy vector. We consider out method to be a first step towards automating a procedure that finds the optimal tradeoff between parallelism and storage space.

Availability Study of Dynamic Voting Algorithms

2023-03-30T03:13:40Z

Availability Study of Dynamic Voting Algorithms Ingols, Kyle; Keidar, Idit Fault tolerant distributed systems often select a primary component to allow a subset of the processes to function when failures occur. The dynamic voting paradigm defines rules for selecting the primary component adaptively: when a partition occurs, if a majority of the previous primary component is connected, a new and possibly smaller primary is chosen. Several studies have shown that dynamic voting leads to more available solutions than other paradigms for maintaining a primary component. However, these studies have assumed that every attempt made by the algorithm to form a new primary component terminates successfully. Unfortunately, in real systems, this is not always the case: a change in connectivity can interrupt the algorithm whiel it is still attempting to form a new primary component; in such cases, algorithms typically block until processes can resolve the outcome of the interrupted attempt. This paper uses simulations to evaluate the effect of interruptions on the availability of dynamic voting algorithms. We study four dynamic voting algorithms, and identify two important characteristics that impact an algorithm's availability in runs with frequent connectivity changes. First, we show that the number of communication rounds exchanged in an algorithm plays a significant role in the availability achieved, especially in the degradation of availability as connectivity changes become more frequent. Second, we show that the number of processes that need to be present in order to resolve past attempts impacts the availability, especially during long runs with numerous connectivity changes.

A General Framework for Highly Available Services based on Group Communication

2023-03-30T03:48:34Z

A General Framework for Highly Available Services based on Group Communication Fekete, Alan; Keidar, Idit We present a general framework for building highly available services. The framework uses group communication to coordinate a collection of servers. Our framework is configurable, in that one can adjust parameters such as the number of servers and the extent to which they are synchronized. We analyze the scenarios that can lead to the service availability being temporarily comprised, and we discuss the tradeoffs that govern the choice of parameters.

Concurrent/Resettable Zero-Knowledge Protocols for NP in the Public Key Model

2023-03-30T03:58:53Z

Concurrent/Resettable Zero-Knowledge Protocols for NP in the Public Key Model Micali, Silvio; Reyzin, Leonid We propose a four-round protocol for concurrent and resettable zero-knowledge arguments for any langauge in NP, assuming the verifier has a pre-registered public-key. We also propose a three-round protocol with an additional timing assumption.

A New Self-Play Experiment in Computer Chess

2023-03-30T03:17:37Z

A New Self-Play Experiment in Computer Chess Heinz, Ernst This paper presents the results of a new self-play experiment in computer chess. It is the _x000C_rst such experiment ever to feature search depths beyond 9 plies and thousands of games for every single match. Overall, we executed 17,150 self-play games (1,050{3,000 per match) in one \\calibration" match and seven \\depth X+1 , X" handicap matches at _x000C_xed iteration depths ranging from 5{12 plies. For the experiment to be realistic and independently repeatable, we relied on a state-of-the-art commercial contestant: Fritz 6 , one of the strongest modern chess pro- grams available. The main result of our new experimentis thatit shows the existence of diminishing returns for additional search in computer chess self-play by Fritz 6 with 95% statistical con_x000C_dence. The dimin- ishing returns manifest themselves by declining rates of won games and reversely increasing rates of drawn games for the deeper searching pro- gram versions. The rate of lost games, however, remains quite steady for the whole depth range of 5{12 plies.

Systematic Testing of Multithreaded Programs

2023-03-30T04:00:14Z

Systematic Testing of Multithreaded Programs Bruening, Derek; Chapin, John We present a practical testing algorithm called ExitBlock that systematically and deterministically finds program errors resulting from unintended timing dependencies. ExitBlock executes a program or a portion of a program on a given input multiple times, enumerating meaningful schedules in order to cover all program behaviors.

Softspec: Software-based Speculative Parallelism

2023-03-30T04:12:12Z

Softspec: Software-based Speculative Parallelism Bruering, Derek; Devabhaktuni, Srikrishna; Amarasinghe, Saman We present Softspec, a technique for parallelizing sequential applications using only simple software mechanisms, requiring no complex program analysis or hardware support. Softspec parallelizes loops whose memory references are stride-predictable.

An Information Theoretic Approach for Shared Bottleneck Inference Based on End-to-end Measurements

2023-03-30T03:31:05Z

An Information Theoretic Approach for Shared Bottleneck Inference Based on End-to-end Measurements Katabi, Dina; Bazzi, Issam; Yang, Xiaowei Recent years have marked a growing interest in studying Internet path characteristics. However, most of the currently available tools to an end system to perform such measurements are slow inaccurate and generate an excessive amount of probing traffic. This paper introduces entropy as a novel and efficient metric for discovering Internet path characteristics based on data collected by an end system. In particular, the paper presents an entropy-based technique that enables an end system to cluster flows it receives according to their shared bottleneck. Our mechanism relies solely on information extracted from the packets' inter-arrivals at the receiver. It does not generate any probing traffic and can use data extracted from both TCP and UDP flows. Moreover, it requires only a small number of packets from each flow, which makes it useful for short-lived flows. We report the result of running the algorithm on simulated data and Internet traffic.

Proving Correctness of a Distributed Shared Memory Implementation

2023-03-30T03:15:38Z

Proving Correctness of a Distributed Shared Memory Implementation Castro, Miquel DiSOM [3,4,2] is a distributed shared memory system that offers users an atomic collection of memory cells provided they satisfy certain well-formedness conditions. This report proves the correctness of DiSOM. The system partitions memory into a set of objects and implicitly associates a read-write lock with each object. Users synchronize accesses to these objects-write implementation guarantees progress and the usual read-write lock exclusions conditions.

Bitwidth Analysis with Application to Silicon Compilation

2023-03-30T04:22:36Z

Bitwidth Analysis with Application to Silicon Compilation Stephenson, Mark; Babb, Jonathan; Amarasinghe, Saman In this paper introduces Bitwise, a compiler that minimizes the bitwidth - the number of bits used to represent each operand - for both integers and pointers in a program. By propagating static information both forward and backward in the program dataflow graph, Bitwise frees in cases where the compiler can determine bitwidths automatically. We find a rich opportunity for bitwidth reductionin modern multimedia and streaming application workloads. For new architectures that support sub-word quantities, we expect that our bitwidth reductions will save power and increase processor performance.

Exploiting Superword Level Parallelism with Multimedia Instruction Sets

2023-03-30T03:16:22Z

Exploiting Superword Level Parallelism with Multimedia Instruction Sets Larsen, Samuel; Amarasinghe, Saman Increasing focus on multimedia applications has prompted the addition of multimedia extensions to most existing general-purpose microprocessors. This added functionality comes primarily in the addition of short SIMD instructions. Unfortunately, access to these instructions is limited to in-line assembly and library calls. Some researchers have proposed using vector compilers as a means of exploiting multimedia instructions. Although vectorization technology is well understood, it is inherently complex and fragile. In addition, it is incapable of locating SIMD-style parallelism within a basic block. In this paper we introduce the concept of Superword Level Parallelism (SLP), a novel way of viewing parallelism in multimedia applications. We believe SLP is fundamentally different from the loop-level parallelism exploited by traditional vector processing, and therefore warrants a different method for extracting it. We have developed a simple and robust compiler technique for detecting SLP that targets basic blocks rather than loop nests. As with techniques designed to extract ILP, ours is able to exploit parallelism both across loop iterations and within badic blocks. The result is an algorithm that provides excellent performance in several application domains. Experiments on scientific and multimedia benchmarks have yielded average performance improvements of 84%, and range as high as 253%.

Strength Reduction of Integer Division and Modulo Operations

2023-03-30T03:56:05Z

Strength Reduction of Integer Division and Modulo Operations Amarasinghe, Saman; Lee, Walter; Greenwald, Ben Integer division, modulo, and remainder operations are expressive and useful operations. They are logical candidates to express complex data accesses such as the wrap-around behavior in queues using ring buffers, array address calculations in data distribution, and cache locality compiler-optimizations. Experienced application programmers, however, avoid them because they are slow. Furthermore, while advances in both hardware in both hardware and software have improved the performance of many parts of a program, few are applicable to division and modulo operations. This trend makes these operations increasingly detrimental to program performance.

A Correctness Proof for a Practical Byzantine-Fault-Tolerant Replication Algorithm

2023-03-30T03:51:06Z

A Correctness Proof for a Practical Byzantine-Fault-Tolerant Replication Algorithm Castro, Miguel We have developed a practical algorithm for state-machine replication [7,11] that tolerates Byzantine faults. The algorithm is described in [4]. It offers a strong safety property - it implements a linearizable [5] object such that all operations invoked on the object execute atomically despite Byzantine failures and concurrency. Unlike previous algorithms [11, 10, 6], ours works correctly in asynchronous systems like the Internet, and it incorporates important optimizations that enable it to outperform previous systems by more than on order of magnitude [4].

The MASC Composable Computing Infrastructure for Intelligent Environments

2023-03-30T04:26:25Z

The MASC Composable Computing Infrastructure for Intelligent Environments Shatterjee, Sandeep; Devadas, Srinivas We present a system architecture and framework for creating rapidly deployable intelligent environments. The rapid pace of innovation of computer hardware and intelligent systems software leads to uncertainty that deters manufacturers from adopting a single processor, network, or software environment for placement into their products. The MASC Composable Computing infrastructure addresses these issues by providing an upgradable hardware and software infrastructure that supports rapid development and deployment, as well as simple and economical maintenance of intelligent environmental systems.

Authenticated Byzantine Fault Tolerance Without Public-Key Cryptography

2023-03-30T03:55:04Z

Authenticated Byzantine Fault Tolerance Without Public-Key Cryptography Castro, Miguel; Liskov, Barbara We have developed a practical state-machine replication algorithm that tolerates Byzantine faults: it works correctly in asynchronous systems like the Internet and it incorporates several optimizations that improve the response time of previous algorithms by more than an order of magnitude.

Can Statistical Zero Knowledge be made Non-interactive? or On the Relationship of SZK and NISZK

2023-03-30T03:38:05Z

Can Statistical Zero Knowledge be made Non-interactive? or On the Relationship of SZK and NISZK Goldreich, Oded; Sahai, Amit; Vadhan, Salil We extend the study of non-interactive statistical zero-knowledge proofs. Our main focus is to compare the class NISZK of problems possessing such non-interactive proofs to the class SZK of problems possessing interactive statistical zero-knowledge proofs. Along these lines, we first show that if statistical zero knowledge is non-trivial then so is non-interactive statistical zero knowledge, where by non-trivial we mean that the class includes problems which are not solvable in probabilistic polynommial-time. (The hypothesis holds under various assumptions, such as the intractability of the Discrete Logarithm Problem.) Furthermore, we show that if NISZK is closed under complement, then in fact SZK = NISZk, i.e. all statistical zero-knowledge proofs can be made non-interactive. The main tools in our analysis are two promise problems that are natural restrictions of promise problems known to be complete for SZK. We show that these restricted problems are in fact completer for NISZK and use this relationship to derive our results comparing the two classes. The two problems refer to the statistical difference, and difference in entropy, respectively, of a given distribution from the uniform one. We also consider a weak form of NISZK, in which only requires that for every inverse polynomial 1/p(n), there exists a simulator which achieves simulator deviation 1/p(n), and show that this weak form of NISZK actually equals NISZK.

A Client-Server Oriented Algorithm for Virtually Synchronous Group Membership in WANs

2023-03-30T03:25:37Z

A Client-Server Oriented Algorithm for Virtually Synchronous Group Membership in WANs Keidar, Idit; Sussman, Jeremy; Marzullo, Keith; Dolev, Danny We describe a novel scalable group membership algorithm designed for wide area networks(WANs.) Our membership service does not evolve from existing LAN-oriented membership services; it was designed explicitly for WANs.

NAIVE - Network Aware Internet Video Encoding

2023-03-30T03:13:52Z

NAIVE - Network Aware Internet Video Encoding Briceno, Hector; Gortler, Steven J.; McMillan, Leonard The distribution of digital video content over computer networks has become commonplace. Unfortunately, most digital video encoding standards do not degrade gracefully in the face of packet losses, which often occur in a bursty fashion. We propose an new video encoding system that scales well with respect to the network's performance and degrades gracefully under packet loss.

Dynamic Load Balancing with Group Communication

2023-03-30T04:05:31Z

Dynamic Load Balancing with Group Communication Dolev, Shlomi; Segala, Roberto; Shvartsman, Alexander A. This work considers the problem of efficiently performing a set of tasks using a network of processors in the setting where the network is subject to dynamic reconfigurations, including partitions and merges. A key challenge for this setting is the implementation of dynamic load balancing that reduces the number of tasks that are performed redundantly because of the reconfigurations. We explore new approaches for load balancing in dynamic networks that can be employed by applications using a group communication service. The group communication services that we consider include a membership service (establishing new groups to reflect dynamic changes) but does not include maintenance of a primary component. For the n-processor, n-task load balancing problem defined in this work, the following specific results are obtained. For the case of fully dynamic changes including fragmentation and merges we show that the termination time of any on-line task assignment algorithm is greater than the termination time of an off-line task assignment algorithm by a factor greater than n/12. We present a load balancing algorithmthat guarantees completion of all tasks in all fragments caused by partitions with work O(n + f ÔøΩ n) in the presence of f fragmentation failures. We develop an effective scheduling strategy for minimizing the task execution redundancy and we prove that our strategy provides each of the n processors with a schedule of ?(n1/3) tasks such that at most one task is performed redundantly by any two processors.

Complexity Results for Single Machine Distance Constrained Scheduling Problems

2023-03-30T04:03:05Z

Complexity Results for Single Machine Distance Constrained Scheduling Problems Engels, Daniel W.; Karger, David; Devadas, Srinivas Scheduling problems that involve timing constraints between tasks occur often in machine shop scheduling (e.g., job shop scheduling problems) and code scheduling during software compilation for pipelined processors (e.g., multiprocessor sequencing and scheduling problems).

Extracting all the Randomness from a Weakly Random Source

2023-03-30T03:08:55Z

Extracting all the Randomness from a Weakly Random Source Vadhan, Salil In this paper, we give two explicit constructions of extractors, both of which work for a source of any min-entropy on strings of length n. The first extracts any constant fraction of the min-entropy using O(log^2 n) additional random bits. The second extracts all the min-entropy using O(log 3 n) additional random bits. Both constructions use fewer truly random bits than any previous. construction which works for all min-entropies ans extracts a constant fraction of the min-entropy.

Local Rules Modeling of Nucleation-Limited Virus Capsid Assembly

2023-03-30T03:07:08Z

Local Rules Modeling of Nucleation-Limited Virus Capsid Assembly Schwartz, Russell; Prevelige, Peter E.; Berger, Bonnie We describe an application of computer modeling to the study of the kinetics of virus capsid (protein shell) assembly. We examine two proposed models of the source of nucleation-limited growth, an observed growth pattern in which initiation of new capsids occurs significantly more slowly than subunit addition onto initiated capsids.

Maps: a Compiler-Managed Memory System for RAW Machines

2023-03-30T04:06:05Z

Maps: a Compiler-Managed Memory System for RAW Machines Barua, Rajeev; Lee, Walter; Amarasinghe, Saman; Agarwal, Anant Microprocessors of the next decade and beyond will be built using VLSI chips employing billions of transistors. In this generation of microprocessors, achieving a high level of parallelism at a reasonable clock speed will require full distribution of mac.

Indolent Closure Creation

2023-03-30T04:01:57Z

Indolent Closure Creation Strumpen, Volker A closure is a representation of a thread in memory, ready to be executed. The goal of this work is to create portable closures that can be transferred across binary incompatible architectures. Consequently, indolent closures are software-implemented, and rely on a copy mechanism which allows for potential data representation conversion on-the-fly.

More on Proofs of Knowledge

2023-03-30T03:58:34Z

More on Proofs of Knowledge Halevi, Shai; Micali, Silvio The notion of proofs of knowledge is central to cryptographhic protocols, and many definitions for it have been proposed. In this work we explore a different facet of this notion, not addressed by prior definitions. Specifically, prior definitions concentrate on capturing the properties of the verifier, and do not pay much attention to the properties of the prover. Our new definition is strictly stronger than previous ones, and captures new and desirable properies. In particular, it guarantees prover feasibility, that is, it guarantees that the time spent by the prover in a proof of knowledge is comparable to that it spends in an "extraction" of this knowledge. Our definition also enables one to consider meaningfully the case of a single, specific prover.

Copmutationally Sound Proofs

2023-03-30T03:37:54Z

Copmutationally Sound Proofs Micali, Silvio This paper puts forward a new notion of a proof based on computational complexity and explores its implications for computation at large. Computationally sound proofs provide, in a novel and meaningful framework, answer to old and new questions in complexity theory. In particular, given a random oracle or a new complexity assumption, they enable us to 1. prove that verifying is easier than deciding for all theorems; 2. provides a quite effective way to prove membership in computationally hard languages (such as C-NP-complete ones); and 3. show that every computation possesses a short certificate vouching its correctness. FInally, if a special type of computationally sound proof exists, we show that Blum's notion of program checking can be meaningfully broadened so as to prove that NP-complete languages are checkable.

Proving Correctness of a Controller Algorithm for the RAID Level 5 System

2023-03-30T03:30:11Z

Proving Correctness of a Controller Algorithm for the RAID Level 5 System Vazirir, Mandana; Lynch, Nancy A.; Wing, Jeannette Mos RAID controllers implemented in industry are complicated and difficult to reason about. This complexity has led to software and hardware systems that are difficult to debug and hard to modify. To overcome this problem Courtright and Gibson have developed a rapidf prototyping framework for RAID architectures which relies on a generic controller algorithm [1]. The designer of a new architecture needs to specify parts of the generic controller algorithm and must justify the validity of the controller algorithm obtained. However the latter task may be difficult due to the concurrency of operations on the disks. This is the reason why it would be useful to provide designers with an automated verification tool tailored specificially for the RAID prototyping system. As a first step towards building such a tool, our approach consists of studying several controller algorithms manually, to determine the key properties that need to be verified. This paper presents the modeling and verification of a controller algorithm for the RAID Level 5 System [5]. We model the system using I/O automata [6], give an external requirements specification, and prove that the model implements its specification. We use a key invariant to find an error in a controller algorithm for the RAID Level 6 System [5].

Signing with Partially Adversarial Hashing

2023-03-30T03:03:37Z

Signing with Partially Adversarial Hashing Micali, Silvio; Reyzin, Leonid Digital signatures usually utilize one-way hash functions designed by other parties. It is thus possible that such hash functions are adverserially designed so as to enable forging signatures in otherwise secure schemes. We initiate the study of signing

On the Inapproximability of the Shortest Vector in a Lattice Within Some Constant Factor

2023-03-30T03:46:53Z

On the Inapproximability of the Shortest Vector in a Lattice Within Some Constant Factor Micciancio, Danielle We show that computing the approximate length of the shortest vector in a lattice within a factor c is NP-hard for randomized reductions for any constant c < ? (2).

Space - Time Scheduling of Instruction-Level Parallelism on a Raw Machine

2023-03-30T04:23:47Z

Space - Time Scheduling of Instruction-Level Parallelism on a Raw Machine Lee, Walter; Barua, R.; Srikrishna, D.; Babb, Jonathan; Sarkar, V.; Amarasinghe, Saman; Agarwal, Anant Advances in VLSI technology will enable chips with over a billion transistors within the next decade. Unfortunately, the centralized-resource architectures of modern microprocessors are ill-suited to exploit such advances. Achieving a high level of parallelism at a reasonable clock speed requires distributing the processor resources - a trend already visible in the dual-register-file architecture of the Alpha 21264.

Specifying and Using a Partitionable Group Communication Service*

2023-03-30T03:49:00Z

Specifying and Using a Partitionable Group Communication Service* Fekete, Alan; Lynch, Nancy A.; Shvartsman, Alexander A. A new, simple formal specification is presented for a partitionable view-oriented group communication service. The specification consists of a state machine to express safety requirements and a timed trace property to express performance and fault-toleran.

Acquisition of a Large Pose-Mosaic Dataset

2023-03-30T04:10:01Z

Acquisition of a Large Pose-Mosaic Dataset Coorg, Satyan; Master, Neel; Teller, Seth We describe the generation of a large pose-mosaic dataset: a collection of several thousand digital images, grouped by spatial position into spherical mosaics, each annotated with estimates of the acquiring camera's 6 DOF pose (3 DOF position and 3 DOF orientation) in an absolute coordinate system. The pose-mosaic dataset was generated by acquiring images, grouped by spatial position into nodes (essentially, spherical mosaics). A prototype mechanical pan-tilt head was manually deployed to acquire the data. Manual surverying provided initial position estimates for each node. A back-projecting scheme provided initial rotational estimates. Relative rotations within each node, along with internal camera parameters, were refined automatically by an optimization-correlation scheme. Relative translations and rotations among nodes were refined according to point correspondences, generated automatically and by a human operator. The resulting pose-imagery is self-consistent under a variety of evaluation metrics. Pose-mosaics are useful "first-class" data objects, for example in automatic reconstruction of textured 3D CAD models which represent urban exteriors.

Lazy Reference Counting for Transactional Storage Systems

2023-03-30T03:20:06Z

Lazy Reference Counting for Transactional Storage Systems Castro, Miguel; Adya, Atul; Liskov, Barbara HAC is a novel technique for managing the direct the client cache in a distributed, persistent object storage system. In a companion paper, we showed that it outperforms other techniques across a wide range of cache sizes and workloads. This report describes HAC's solution to a specific problem: how to discard indirection table entries in an indirect pointer swizzling scheme.

The Sensitivity of Communication Mechanisms to Bandwidth and Latency

2023-03-30T04:12:40Z

The Sensitivity of Communication Mechanisms to Bandwidth and Latency Chong, Frederic T.; Barua, Rajeev; Dahlgren, Fredrik; Kubiatowicz, John D.; Agarwal, Anant The goal of this paper is to gain insight into the relative performance of communication mechanisms as bisection bandwidth and network latency vary. We compare shared memory with and without prefetching, message passing with interrupts and with polling, and bulk transfer via DMA. We present two sets of experiments involing four irregular applications on the MIT Alewife multiprocessor. First, we introduce I/O cross-traffic to vary bisection bandwidth. Second, we change processor clock speeds to vary relative network latency. We establish a framework from which to understand a range of results. On Alewife, shared memory provides good performance, even on producer-consumer applications with little data-reuse. On machines with lower bisection bandwidth and higher network latency, however, message-passing mechanisms become important. In particular, the high communication volume of shared memory threatens to become difficult to support on future machines without expensive, high-dimensional networks. Furthermore, the round-trip nature of shared memory may not be able to tolerate the latencies of future networks.

Matching and Pose Refinement with Camera Pose Estimates

2023-03-30T03:01:23Z

Matching and Pose Refinement with Camera Pose Estimates Coorg, Satyan; Teller, Seth This paper describes novel algorithms that use absolute camera pose information to identify correspondence among point features in hundreds or thousands of images. Our incidence counting algorithm is a geometric approach to matching: it makes features by extruding them into an absolute 3-D coordinate system, then searching 3-D space for regions into which many features project.

Light Traps

2023-03-30T03:55:32Z

Light Traps Dawson, R.J. Macg.; McDonald, B.E.; Mycielski, J.; Pachter, L. In the February 1992 issue of the American Mathematical Monthly, J. E. Connett [1] asked whether it is possible to construct a 'light trap': a reflective-sided container with the property that a beam of light, shone into it from an appropriate direction, would be reflected inside it over and over again and never escape. Connett suggests that such a trap might be of value as a device to store light rays; however, the market for escape-proof golf holes might be even more lucrative!

Protein Folding in the Generalized Hydrophobic-Polar Model on the Triangular Lattice

2023-03-30T03:48:31Z

Protein Folding in the Generalized Hydrophobic-Polar Model on the Triangular Lattice Decatur, Scott E. We consider the problem of determining the three-dimensional folding of a protein given its one-dimensional amino sequence. The model we use is based on the Hydrophobic-Polar (HP) model [2] on cubic lattices in which the goal is to find the fold with the maximum number of contacts between non-covalently linked hydrophobic amino acids.

A Survey of Active Network Research

2023-03-30T03:40:30Z

A Survey of Active Network Research Tennenhouse, David L.; Smith, Jonathan M.; Sincoskie, W. David; Wetherall, David J.; Minden, Gary J. Active networks are a novel approach to network architecture in which the switches of the network perform customized computations on the messages flowing through them. This approach is motivated by both lead user applications, which perform user-driven computation at nodes within the network today, and the emergence of mobile code technologies that make dynamic network service innovation attainable. In this paper, we discuss two approaches to the realization of active networks and provide a snapshot of the current research issues and activities.

UDM: User Direct Messaging for General-Purpose Multiprocessing

2023-03-30T04:21:50Z

UDM: User Direct Messaging for General-Purpose Multiprocessing Mackenzie, Kenneth; Kubiatowicz, John; Frank, Matthew; Lee, Walter; Victor, Lee; Agarwal, Anant; Kaashoek, M. Frans User Direct Messaging (UDM) allows user-level, processor-to- processor messaging to coexist with general multiprogramming and virtual memory. Direct messaging, where processors launch and receive messages in tens of cycles directly via network interface FIFO's as opposed to indirectly via memory, offers high message bandwidth and low delivery latency by avoiding memory delay and buffer management overhead.

Verification of the Randomized Consensus Algorithm of Aspnes and Herlihy: a Case Study*

2023-03-30T03:44:07Z

Verification of the Randomized Consensus Algorithm of Aspnes and Herlihy: a Case Study* Pogosyants, Anna; Segala, Roberto; Lynch, Nancy A. The Probabilistic I/O Automaton model of [20] is used as the basis for a formal presentation and proof of the randomized consensus algorithm of Aspnes and Herlihy. The algorithm guarantees termination within expected polynomial time. The Aspnes-Herlihy algorithm is a rather complex algorithm. Processes move through a succesion of asynchronous rounds, attempting to agree at each round. At each round, the agreement attempt involves a distributed random walk.

An Oblivious Data Structure and its Applications to Cryptography

2023-03-30T03:08:13Z

An Oblivious Data Structure and its Applications to Cryptography Micciancio, Danielle

Parameterized Types and Java

2023-03-30T03:08:45Z

Parameterized Types and Java Bank, Joseph A.; Liskov, Barbara; Myers, Albert C. Java offers the real possibility that most programs can be written in a type-safe language However, for Java to be broadly useful, it needs additional expressive power. This paper extends Java in one area where more power is needed: support for parametric polymorphism, which allows the definition and implementation of generic abstractions.

Conservative Radiance Interpolants for Ray Tracing

2023-03-30T04:05:56Z

Conservative Radiance Interpolants for Ray Tracing Teller, Seth; Bala, Kavita; Dorsey, Julie Classical ray-tracing algorithms compute radiance returning to the eye along one or more sample rays through each pixel of an image. The output of a ray-tracing algorithm, although potentially photorealistic, is a two-dimensional quality an image array of radiance values and is not directly useful from any viewpoint other than the one for which it was computed.

Cilk: An Efficient Multithreaded Runtime System

2023-03-30T04:05:35Z

Cilk: An Efficient Multithreaded Runtime System Blumofe, Robert D.; Joerg, Christopher F.; Kuszmaul, Bradley C.; Leiserson, Charles E.; Randall, Keith H.; Yuli, Zhou Cilk (pronounced "silk") is a C-based runtime system for multithreaded parallel programming. In this paper, we document the efficiency of the Cilk work-stealing scheduler, both empirically and analytically. We show that on real and synthetic applications, the "work" and "critical-path length" of a Cilk computation can be used to model performance accurately.

A Brief Overview of the GSM Radio Interface

2023-03-30T04:16:18Z

A Brief Overview of the GSM Radio Interface Turletti, Thierry This technical memorandum contains a compilation of several papers, reports and books relative to the GSM-900 radio interface. It is not exhaustive and it is restricted to the Traffic Channel/Full-Rate Speech (TCH/FS).

A Spacially and Temporally Coherent Object Space Visibility Algorithm

2023-03-30T04:04:06Z

A Spacially and Temporally Coherent Object Space Visibility Algorithm Coorg, Satyan; Teller, Seth Efficiently identifying polygons that are visible from a changing synthetic viewpoint is an important problem in computer graphics. In many complex geometric models, most parts of the model are invisible from the instantaneous viewpoint. Despite this, hidden-surface algorithms like the z-buffer or BSP tree often expend significant computation processing invisible portions of the model.

Modelling and Verification of Automated Transit Systems, Using Timed Automata, Invariants and Simulations

2023-03-30T04:07:38Z

Modelling and Verification of Automated Transit Systems, Using Timed Automata, Invariants and Simulations Lynch, Nancy A. This paper contains an overview of recent and current work in the M.I.T. Theory of Distributed Systems research group on modelling, verifying and analyzing problems arising in automated transit systems. The problems we consider are inspired by design work in Personal Rapid Transit (PRT) project at Raytheon (as described to us by Toy Johnson, Steve Spielman and Norm Delisle), and in the California PATH project (as described to us by Shankar Sastry, Datta Godbole and John Lygeros) [7, 6,13, 3].

Hybrid I/O Automata

2023-03-30T04:04:23Z

Hybrid I/O Automata Lynch, Nancy A.; Segala, Roberto; Vaandrager, Frits; Weinberg, H. B. We propose a new hybrid I/O automaton model that is capable of describing both continuous and discrete behavior. The model, which extends the timed I/O automaton model of [12, 7] and the phase transition system models of [15, 2], allows communication among components using both shared variables and shared actions.

Enhanced Certificate Revocation System

2023-03-30T15:19:14Z

Enhanced Certificate Revocation System Micali, Silvio We apply off-linne digital signatures to provide a novel approach to certificate revocation. Our approach dismisses with traditional CRLs and yields pubilc-key infrastructures that are several-hundred times cheaper to run than traditional ones. More generally, our technology also yields effective methods to lengthen the validity of a digital signature.

Symmetric Alternation Captures BPP

2023-03-30T04:17:45Z

Symmetric Alternation Captures BPP Russell, Alexander; Sundaram, Ravi We introduce the natural class Sp2 containing those languages which may be expressed in terms of two symmetric quantifiers. This class lies between ? and ? and naturally generates a "symmetric" hierarchy corresponding to the polynomial-time hierarchy. We demonstrate, using the probabilistic method, new containment theorems for BPP.

Temporally Coherent Conservative Visibility

2023-03-30T15:16:01Z

Temporally Coherent Conservative Visibility Coorg, Satvan; Teller, Seth Efficiently identifying polygons that are visible from a changing synthetic viewpoint is an important problem in computer graphics. even with hardware support, simple algorithms like depth-buffering cannot achieve interactive frame rates when applied to geometric models with many polygons. However, a visibility algorithm that exploits the occlusion properties of the scene to identify a superset of visible polygons, without touching most invisible polygons, could achieve fast rates while viewing such models.

Automatic Partitioning of Parallel Loops and Data Arrays for Distributed Shared-memory Multiprocessors

2023-03-30T04:25:27Z

Automatic Partitioning of Parallel Loops and Data Arrays for Distributed Shared-memory Multiprocessors Agarwal, Anant; Kranz, David A.; Natarajan, Venkat This paper presents a theoretical framework for automatically partitioning parallel loops to minimize cache coherency traffic on shared-memory multiprocessors. While several previous papers have looked at hyperplane partitioning of iteration spaces to reduce communication traffic, the problem of deriving the optimal tiling parameters for minimal communication in loops with general affine index expressions had remained open. Our paper solves this open problem by presenting a method for deriving an optimal hyperparallelepiped tiling of iteration spaces for minimal communication in multiprocessors with caches. We show that the same theoretical framework can also be used to determine optimal tiling parameters for both data and loop partitioning in distributed memory multicomputers. Our framework uses matrices to represent iteration and data space mappings and the notion of uniformly intersecting references to capture temporal locality in array references. We introduce the notion of data footprints to estimate the communication traffic between processors and use linear algebraic methods and lattice theory to compute precisely the size of data footprints. We have implemented this framework in a compiler for Alewife, a distributed shared-memory multiprocessor.

Guaranteeds Partial Key-escrow

2023-03-30T03:28:01Z

Guaranteeds Partial Key-escrow Micali, Silvio

On the Redundancy Achieved by Huffman Codes

2023-03-30T04:12:44Z

On the Redundancy Achieved by Huffman Codes De Prisco, Roberto; De Santis, Alfredo It has been recently proved that the redundancy r of any discrete memoryless source satisfies r < 1 -H(pn), where pn is the least likely source letter probability. This bound is achieved only by sources consisting of two letters. We prove a sharper bound if the number of source letters is greater than two. Also provided is a new upper bound on r, as function of the two least likely source letter probabilities which improve on previous results.

The Power of Team Exploration: Two Robots Can Learn Unlabeled Directed Graphs

2023-03-30T03:24:29Z

The Power of Team Exploration: Two Robots Can Learn Unlabeled Directed Graphs Bender, Michael A.; Slonim, Donna K. We show that two cooperating robots can learn exactly any strongly-connected directed graph with n indistinguishable nodes in expected time polynomial in n. We introduce a new type of homing sequence for robots, which helps the robots recognize certain previously-seen nodes. We represent an algorithm in which the robots learn the graph and the homing sequence simultaneously by actively wandering through the graph.

What are principal typings and what are they good for?

2023-03-30T15:09:28Z

Rank 2 Type Systems and Recursive Definitions

2023-03-30T14:58:22Z

Charge-Based Proportional Scheduling

2023-03-30T03:20:53Z

Charge-Based Proportional Scheduling Maheshwari, Umesh Most priority-based schedulers lack the ability to control the relative execution rates of applications. A recent scheme, called lottery scheduling [WW94], uses randomization to control the execution rates of threads in proportion to the tickets allocated to them.

Stride Scheduling: Deterministic Proportional- Share Resource Management

2023-03-30T03:41:59Z

Stride Scheduling: Deterministic Proportional- Share Resource Management Waldspurger, Carl A.; Weihl, William E. This paper presents stride scheduling, a deterministic scheduling technique that efficiently supports the same flexible resource management abstractions introduced by lottery scheduling. Compared to lottery scheduling, stride scheduling archives significantly improved accuracy over relative throughput rates, with significantly lower response time variability.

Local Rule Switching Mechanism for Viral Shell Geometry

2023-03-30T03:57:38Z

Local Rule Switching Mechanism for Viral Shell Geometry Berger, Bonnie; Shor, Peter W. In a previous paper [Berger et al., PNAS 91 7732,1994] a theory of virus shell formation was proposed in which shell assembly is directed by local interactions of the coat ans scaffolding subunits. This theory requires that the same chemical subunits assume different, stable conformations depending on their position in the shell.

'C: A Language for High-Level, Efficient, and Machine-independant Dynamic Code Generation

2023-03-30T03:47:34Z

'C: A Language for High-Level, Efficient, and Machine-independant Dynamic Code Generation Engler, Dawson R.; Hsieh, Wilson C.; Kaashoek, M. Frans Dynamic code generation allows specialized code sequences to be crafted using runtime information. Since this information is by definition not available statically, the use of dynamic code generation can achieve performance inherently beyond that of static code generation. Previous attempts to support dynamic code generation have been low-leveled, expensive, or machine-dependent.

Algorithms for Modeling and Measuring Proteins

2023-03-30T03:57:35Z

Algorithms for Modeling and Measuring Proteins Slonim, Donna K. In this paper we investigate efficient algorithms for computing the volume and surface area of protein molecules are modeled by sets of overlapping spheres in R 3. We summarize and critique three papers in the field, and we add several new contributions of our own.

A Case Study of Shared Memory and Message Passing: The Triangle Puzzle

2023-03-30T03:30:51Z

A Case Study of Shared Memory and Message Passing: The Triangle Puzzle Lew, Kevin This thesis is the first controlled case study that compares shared-memory and message-passing implementations of an application that solves the triangle puzzle and runs on actual hardware: only the communication interfaces used by the implementations vary; all other system components remained fixed. The implementations run on the MIT Alewife machine, a cache-coherent, distributed-shared-memory multiprocessor that efficiently supports both the shared-memory and message-passing programming models.

Communication-Minimal Partitioning of Parallel Loops and Data Arrays for Cache-Coherent Distributed -Memory Multiprocess

2023-03-30T03:38:55Z

Communication-Minimal Partitioning of Parallel Loops and Data Arrays for Cache-Coherent Distributed -Memory Multiprocess Barua, Rajeev; Kranz, David; Agarwal, Anant Harnessing the full performance potential of cache-coherent distributed shared memory multiprocessors without inordinate user effort requires a compilation technology that can automatically manage multiple levels of memory hierarchy. This paper describes a working compiler for such machines that automatically partitions loops and data arrays to optimize locality of access.

Addressing Partitioned Arrays in Distributed Memory Multiprocessors - the Software Virtual Memory Approach

2023-03-30T03:19:50Z

Addressing Partitioned Arrays in Distributed Memory Multiprocessors - the Software Virtual Memory Approach Barua, Rajeev; Kranz, David; Agarwal, Anant Harnessing the full performance potential of cache-coherent distributed shared memory multiprocessors without inordinate user effort requires a compilation technology that can automatically manage multiple levels of memory hierarchy. This paper describes a working compiler for such machines that automatically partitions loops and data arrays to optimize locality of access.

Symmetric Alteration Captures BPP

2023-03-30T03:52:33Z

Symmetric Alteration Captures BPP Russell, Alexander; Sundaram, Ravi We introduce the natural class Sp2 containing those languages which may be expressed terms of two symmetric quantifiers. This class lies between ?p2 and ? and naturally generates a "symmetric" hierarchy corresponding to the polynomial-time hierarchy. We demonstrate, using the probabilistic method, new containment theorems for BPP.

On the Mathematics of Virus Shell Assembly

2023-03-30T03:28:56Z

On the Mathematics of Virus Shell Assembly Berger, Bonnie; Shor, Peter W. A local rule theory is developed which shows that the self-assembly of icosahedral virus shells may depend on only the lower-level interactions of a protein subunit with its neighbors, i.e. local rules, rather than on larger structural building blocks. The local rule theory provides a framework for understanding the assembly of icosahedral viruses.

Implementing Sequentially Consistant Shared Objects using Broadcast and Point-To-Point Communications

2023-03-30T03:08:36Z

Implementing Sequentially Consistant Shared Objects using Broadcast and Point-To-Point Communications Fekete, Alan; Kaashoek, M. Frans; Lynch, Nancy A. A distributed algorithm that implements a sequentially consistent collection of shared read/update objects using a combination of broadcast and point-to-point communication is presented and proved correct. This algorithm is a generalization of one used in the Orca shared object system. The algorithm caches objects in the local memory of processors according to application needs; each read operation accesses a single copy of the object, while each update accesses all copies. Copies of all the objects are kept consistent using a strategy based on sequence numbers for broadcasts.

CRL: High - Performance All-Software Distributed Shared Memory*

2023-03-30T03:41:21Z

CRL: High - Performance All-Software Distributed Shared Memory* Johnson, Kirk L.; Kaashoek, M. Frans; Wallach, Deborah A. This paper introduces the C Region Library (CRL), a new all-software distributed shared memory (DSM) system. CRL requires no special compiler, hardware , or operating system support beyond the ability to send and receive messages. It provides a simple, portable shared address space programming model that it capable of delivering good performance on a wide range of multiprocessor and distributed system architectures.

Piecemeal Graph Exploration by a Mobile Robot*

2023-03-30T03:03:23Z

Piecemeal Graph Exploration by a Mobile Robot* Awerbuch, Baruch; Betke, Margrit; Rivest, Ronald; Singh, Mona We study how a mobile robot can piecemeal learn an unknown environment. The robot's goal is to learn a complete map of its environment, while satisfying the constraint that it must return every so often to its starting position (for refueling, say). The environment is modelled as an arbitrary, undirected graph, which is initially unknown to the robot.

Using Non-interactive Proofs to Achieve Independence Efficiently and Securely

2023-03-30T04:01:48Z

Using Non-interactive Proofs to Achieve Independence Efficiently and Securely Gennaro, Rosario Independence or simultaneous broadcast is a fundamental tool to achieve security in fault tolerant distributed computing. It allows n players to commit to independently chosen values. In this paper we present a constant round protocol to perform this task. Previous solutions were 0(log n) rounds. In the process we develop a new and stronger formal definition from this problem.

The Use of the Domain Name System for Dynamic References in an Online Library

2023-03-30T04:16:58Z

The Use of the Domain Name System for Dynamic References in an Online Library Alavi, Ali Persistent, dynamic references (or links) to remove documents are an essential part of an online library. This thesis examines two distributed database systems, X.500 and the Domain Name System(DNS), upon which to build dynamic references. DNS was chosen and was used to design a model and build a sample dynamic reference system. This system seems to exhibit the scalability, robustness, usuability, and efficiency necessary for building global distributed online libraries.

How Can We Compute with Arrays of Nanstructures?

2023-03-30T03:59:03Z

How Can We Compute with Arrays of Nanstructures? Biafore, Michael In part the goal of the Ultra Program is to extract useful computation from nanometer scale effects. To accomplish this goal those of us who are computer scientists must communicate clearly to those of you who are chemists and device physicists precisely what kinds of "computational primitives" you need to obtain from a nanoscale structure before we can contemplate using it as a building block for ultra-dense ultra-fast computation.

The Generalized Railroad Crossing: A Case Study in Formali Verification of Real-time Systems

2023-03-30T03:57:14Z

The Generalized Railroad Crossing: A Case Study in Formali Verification of Real-time Systems Heitmeyer, Constance; Lynch, Nancy A. A new solution to the Generalized Railroad Crossing problem, based on timed automata, invariants and simulation mappings, is presented and evaluated. The solution shows formally the correspondence between four system descriptions: an axiomatic specification, an operational specification, a discrete system implementation, and a system implementation that works with a continuous gate model.

An Efficient Implementation of A Hierarchical Weighted Fair Queue Packet Scheduler

2023-03-30T03:12:11Z

An Efficient Implementation of A Hierarchical Weighted Fair Queue Packet Scheduler Ndiaye, Oumar The technical developments in computer networks in recent years have spawned the possibility of merging different services into a single Integrated Service Packet Network (ISPN). The types of service quality required by each of the individual services in an ISPN often differ greatly. Thus, the packet scheduling algorithms used in such networks must be flexible enough to allocate the available link shares according to the service quality requirements of the different services.

Application of Minimal Perfect Hashing in Main Memory Indexing

2023-03-30T03:57:17Z

Application of Minimal Perfect Hashing in Main Memory Indexing Ho, Yuk With the rapid decrease in the cost of random access memory (RAM), it will soon become economically feasible to place full-text indexes of a library in main memory. One essential component of the indexing system is a hashing algorithm, which maps a keyword into the memory address of the index information corresponding to that keyword. This thesis studies the application of the minimal perfect hashing algorithm in main memory indexing. This algorithm is integrated into the index search engine of the Library 2000 system, a digital on-line library system. The performance if this algorithm is compared with that of the open-address hashing scheme. We find that although the minimal perfect hashing algorithm needs fewer keyword comparisons per keyword search on average, its hashing performance is slower than the open-addressing scheme.

Hybrid Caching for Scalable Oject Systems (Think Globally, Act Locally)

2023-03-30T03:52:18Z

Hybrid Caching for Scalable Oject Systems (Think Globally, Act Locally) O'Toole, James; Shrira, Liuba Object-based client caching allows clients to keep more frequently accessed objects while discarding colder objects that reside on the same page. However, when these objects are modified and sent to the server, it may need to read the corresponding page from disk to install the update. These installation reads are not required with a page-based cache because whole pages are sent to the server.

Opportunistic Log: Efficient Installation Reads in a Reliable Object Server

2023-03-30T04:21:07Z

Opportunistic Log: Efficient Installation Reads in a Reliable Object Server O'Toole, James; Shrira, Liuba In a distributed storage system, client caches managed on the basis of small granularity objects can provide better memory utilization then page-based caches. However, object servers, unlike page servers, must perform additional disk reads. These installation reads are required to install modified objects onto their corresponding disk pages.

Coordinated Resource Management in a Replicated Objected Server

2023-03-30T03:22:09Z

Coordinated Resource Management in a Replicated Objected Server Ghemawat, Sanjay; Gruber, Robert; O'Toole, James, Jr.; Shrira, Liuba We propose several new techniques for resource management in a replicated object server. By coordinating cache and disk usage among the replicas, these techniques increase throughput and reduce fetch latency. Cache splitting speeds up fetches by avoiding redundant cache entries, effectively increasing the cache size. Coordinated writing coordinates disk writes to ensure that one replica is always available to service fetches. We investigate the performance of a replicated server using these techniques, and we present simulation results showing that these techniques provide substantial performance improvements across a variety of workloads.

Optimal Clock Synchronization Under Different Delay Assumptions

2023-03-30T04:25:00Z

Optimal Clock Synchronization Under Different Delay Assumptions Attiya, Hagit; Herzberg, Amir; Rajsbaum, Sergio The problem of achieving optimal clock synchronization in a communication network with arbitrary topology and perfect clocks (that do not drift) is studied. Clock synchronization algorithms are presented for a large family of delay assumptions. Our algorithms are modular and consist of three major components. The first component holds for any type of delay assumptions; the second component holds for a large, natural family of local delay assumptions; the third component has to be tailored for each specific delay assumption. Optimal clock synchronization algorithms are derived for several types of delay assumptions by appropriately tuning the third component. The delay assumptions include lower and upper delay bounds, no bounds at all, and bounds on the difference of the delay in opposite directions. In addition, our model handles systems where some processors are connected by broadcast networks in which every message arrives to all processors at approximately the same time. A composition theorem allows combinations of different assumptions for different lins or even for the same link; such mixtures are common in practice. Our results acheive the best possible precision in each execution. This notion of optimality is stronger than the more common notion of worst case optimality. The new notion of optimality applied to systems where the worst case behavior of any clock synchronization algorithm is inherently unbounded.

FUGU: Implementing Translation and Protection in a Multiuser, Multimodel Multiprocessor

2023-03-30T03:45:09Z

FUGU: Implementing Translation and Protection in a Multiuser, Multimodel Multiprocessor Mackenzie, Kenneth; Kubiatowicz, John; Agarwal, Anant; Kaashoek, M. Frans Multimodel multiprocessors provide both shared memory and message passing primitives to the user for efficient communication. In a multiuser machine, translation permits machine resource to be virtualized and protection permits users to be isolated. The challenge in a multiuser multiprocessor is to provide translation and protection sufficient for general-purpose computing without compromising communication performance, particularly the performance of communication between parallel threads belong to the same computation.

Verifiable Secret Sharing as Secure Computation

2023-03-30T03:48:43Z

Verifiable Secret Sharing as Secure Computation Gennaro, Rosario; Micali, Silvio We present a stronger notion of verifiable secret sharing and exhibit a protocol implementing it. We show that our new notion is preferable to the old ones whenever verifiable secret sharing is used as a tool within larger protocols, rather than being a goal in itself.

A Secure and Efficient Digital Signature Algorithm

2023-03-30T04:21:04Z

A Secure and Efficient Digital Signature Algorithm Micali, Silvio

PAC-Learning Prolog Clauses With or Without Errors

2023-03-30T04:20:05Z

PAC-Learning Prolog Clauses With or Without Errors Gennaro, Rosario Recently researchers have been interested in trying to expand the domain of learnability to subsets of first-order logic, in particular Prolog programs. This new research area has been named Inductive Logic Programming (ILP). In a nutshell we can describe a generic ILP problem as following: given a set E of (positive and negative) examples of a target predicate, and some background knowledge B about the world (usually a logic program including facts and auxiliary predicates), the task is to find a logic program H (our hypothesis) such that all positive examples can be deduced from B and H, while no negative example can. In this paper we review some of the results achieved in this area and discuss the techniques used. Moreover we prove the following new results: (1) Predicates described by non-recursive, local clauses of at most k literals are PAC-learnable under any distribution. This generalizes a previous result that was valid only for constrained clauses. (2) Predicates that are described by k non-recursive local clauses are PAC-learnable under any distribution. This generalizes a previous result that was non constructive and valid only under some class of distributions. Finally we introduce what we believe is the first theoretical framework for learning Prolog clauses in the presence of errors. To this purpose we introduce a new noise model, that we call the fixed attribute noise model, for learning propositional concepts over the Boolean domain. This new noise model can be of its own interest.

A Comparison of Simulation Techniques and Algebraic Techniques for Verifying Concurrent Systems

2023-03-30T03:48:33Z

A Comparison of Simulation Techniques and Algebraic Techniques for Verifying Concurrent Systems Lynch, Nancy A.; Segala, Roberto Simulation-based assertional techniques and process algebraic techniques are two of the major methods that have been proposed for the verification of concurrent and distributed systems. It is shown how each of these techniques can be applied to the task of verifying systems described as input/output automata; both of these ways, first using forward simulations, an execution correspondence lemma, and a simple fairness argument, and second using deductions within the process algebra DIOA for I/O automata. An extended evaluation and comparison of the two methods is given.

Anatomy of a Message in the Alewife Multiprocessor

2023-03-30T03:44:53Z

Anatomy of a Message in the Alewife Multiprocessor Kubiatowicz, John; Agarwal, Anant

Analyzing Multiprocessor Cache Behavior Through Data Reference Modeling

2023-03-30T03:01:59Z

Analyzing Multiprocessor Cache Behavior Through Data Reference Modeling Tsai, Jory; Agarwal, Anant This paper develops a data reference modeling technique to estimate with high accuracy the cache miss ratio in cache-coherent multiprocessors. The technique involves analyzing the dynamic data referencing behavior of parallel algorithms. Data reference modeling first identifies of different types of shared data blocks accessed during the execution of a parallel algorithm, then captures in a few parameters the cache behavior of each shared block as a function of the problem size, number of processors, and cache size, and finally constructs an analytical expression for each algorithm to estimate the cache miss ratio.

Simulation Techniques for Proving Properties of Real-time Systems

2023-03-30T03:17:46Z

Simulation Techniques for Proving Properties of Real-time Systems Lynch, Nancy A. The method of simulations is an important technique for reasoning about real-time and other timing-based systems. It is adapted from an analogous method for untimed systems. This paper presents the simulation method in the context of a very general automaton (i.e., labelled transition system) model for timing-based systems. Sketches are presented of several typical examples for which the method has been used successfully. other complementary tools are also described, in particular invariants for safety proofs, progress functions for timing proofs, and execution correspondences for liveness proofs.

Software-Extended Coherent Shared Memory: Performance and Cost

2023-03-30T04:06:16Z

Software-Extended Coherent Shared Memory: Performance and Cost Chaiken, David; Agarwal, Anant This paper evaluates the tradeoffs involved when designing a directory-based protocol that implements coherent shared memory through a combination of hardware and software mechanisms. The fundamental design decisions involve balancing the size and cost of the hardware directory and control, the complexity of the software interface, and the overall performance of the system. In order to study these design problems, we experiment with a spectrum of cache-coherence schemes, raging from a full-map directory that supports all sharing patterns in hardware to an implementation that performs all memory-side actions in software.

The Revitalized Relationship Between Probabilistically Checkable Debate Systems, IP, and PSpace

2023-03-30T04:07:30Z

The Revitalized Relationship Between Probabilistically Checkable Debate Systems, IP, and PSpace Russell, Alexander; Sundaram, Ravi In 1990, PSPACE was shown to be identical to IP, the class of languages with interactive proofs [11, 2]. Recently, PSPACE was again recharacterized, this time in terms of (Random) Probabilistically Checkable Debate Systems [4, 5]. In particular, it was shown that SPACE = PCDS[log n, 1] = RPCDS [log n, 1]. We study the relativized behaviour of the classes defined by these debates systems in comparison with the classes IP and PSPACE.

Virtual Wires: Overcoming Pin Limitations in FPGA-based Logic Emulators

2023-03-30T03:01:29Z

Virtual Wires: Overcoming Pin Limitations in FPGA-based Logic Emulators Babb, Jonathan; Tessier, Russell; Agarwal, Anant Existing FPGA-based logic emulators suffer from limited inter-chip communication bandwidth, resulting in low gate utilization (10 20 percent). This resource imbalance increases the number of chips needed to emulate a particular logic design and thereby decreases emulation speed, since signals must cross more chip boundaries. Current emulators only use a fraction of potential communication bandwidth because they dedicate each FPGA pin (physical wire) to a single emulated signal (logical wire). These logical wires are not active simultaneously are only switched at emulation clock speeds.

Compile-time Loop Splitting for Distributed Memory Multiprocessors

2023-03-30T03:45:24Z

Compile-time Loop Splitting for Distributed Memory Multiprocessors Tanguay, Donald O., Jr. In a distributed memory multiprocessor, a program's task is partitioned among the processors to exploit parallelism, and the data are partitioned to increase referential locality. Though the purpose of partitioning is to shorten the execution time of an algorithm, each data reference can become a complex expression based upon the data partitions. As an attempt to minimize the computation needed for array references, loop splitting can further divide a partitioned loop into segments that allow the code hoisting and strength reduction optimizations. This thesis introduces two methods of loop splitting, rational and interval. While rational splitting divides the loop into equal-length GCD segments, interval splitting specifies segments as an explicit list of intervals. These two methods have been implemented and studied. Under our execution model, the loop in the algorithms analyzed executes an average of 2 to 3 times faster after loop splitting.

Column-associative Caches: A Technique for Reducing the Miss Rate of Direct-mapped Caches

2023-03-30T03:57:24Z

Column-associative Caches: A Technique for Reducing the Miss Rate of Direct-mapped Caches Agarwal, Anant; Pudar, Steven D. Direct-mapped caches are a popular design choice for high-performance processors; unfortunately, direct-mapped caches suffer systematic interference misses when more than one address map into the same cache set. This paper describes the design of column-associative caches, which minimize the conflicts that arise in direct-mapped accesses by allowing conflicting addresses to dynamically choose alternate hashing functions, so that most of the conflicting data can reside in the cache. At the same time, however, the critical hit access path is unchanged. The key to implementing this scheme efficiently is the addition to each cache set of a rehash bit, which indicates whether that set stores data that is referenced by an alternate hashing function. When multiple addresses map into the same location, these rehashed locations are preferentially replaced. We demonstrate using trace-driven simulations and an analytical model that a column-associative cache removed virtually all interference misses for large caches, without altering the critical hit access time.

Modeling Multiprogrammed Caches

2023-03-30T04:16:04Z

Modeling Multiprogrammed Caches Agarwal, Anant This paper presents a simple, yet accurate, model for multiprogrammed caches and validates it against trace-driven simulation. The model takes into account nonstationary behavior of processes and process sharing. By making judicious approximations, the paper shows that a very simple expression of the form u^2(p - 1)/tS accurately models the multiprogramming component of the miss rate of large direct-mapped caches. In the above expression, t is the context-switching interval, S is the cache size in blocks, p is the number of processes, and u is the number of unique blocks accesses by a process during the interval t.

Forward and Backward Simulations Part II: Timing-based Systems

2023-03-30T04:23:25Z

Forward and Backward Simulations Part II: Timing-based Systems Lynch, Nancy A.; Vaandrager, Frits A general automaton model for timing-based systems is presented and is used as the context for developing a variety of simulation proof techniques for such systems. These techniques include (1) refinments, (2) forward and backward simulations, (3) hybrid forward-backward and backward-forward simulations, and (4) history and prophecy relations. Relationships between the different types of simulations, as well as soundness and completeness results, are stated and proved.

Forward and Backward Simulations Part I: Untimed Systems (Replaces TM-486)

2023-03-30T03:54:54Z

Forward and Backward Simulations Part I: Untimed Systems (Replaces TM-486) Lynch, Nancy A.; Vaandrager, Frits A unified, comprehensive presentation of simulation techniques for verification of concurrent systems is given, in terms of a simple untimed automaton model. In particular, (1) refinements, (2) forward and backward simulations, (3) hybrid forward-backward and backward-forward simulations, and (4) history and prophecy relations are defined.

Failsafe Key Escrow Systems (Extended Abstract)

2023-03-30T03:43:25Z

Failsafe Key Escrow Systems (Extended Abstract) Leighton, Tom This paper describes a method for escrowing cryptographic keys, which we call Failsafe Key Escrow (FKE). The method is substantially more secure than alternative such as the Fair Public Key Cryptosystem approach advocated by Micali, and it is particular well suited for use in escrowing DSS keys.

Automatic Partitioning of Parallel Loops for Cache-coherent Multiprocessors

2023-03-30T04:06:10Z

Automatic Partitioning of Parallel Loops for Cache-coherent Multiprocessors Agarwal, Anant; Kranz, David; Natarajan, Venkat This paper presents a theoretical framework for automatically partitioning parallel loops to minimize cache coherency traffic on shared-memory multiprocessors. The framework introduces the notion of uniformly intersecting references to capture temporal locality in array references, and the idea of data footprints to estimate the communication traffic between processors. The framework uses lattice theory to compute the size of data footprints. We demonstrate that algorithms based on our framework discover optimal partitions in many cases, such as non-communication-free parallelogram partitions of affine loop index functions, which were not handled by previous algorithms. We also show that our framework correctly reproduces results from previous loop partitioning algorithms proposed by Abraham and Hudak and by Sadayappan and Ramanujam. Because they deal only with index expressions, the algorithms are computationally efficient as well. We have implemented a subset of this framework for rectangular partitioning in a compiler for the cache-coherent Alewife machine.

Action Transducers and Timed Automata

2023-03-30T04:08:22Z

Action Transducers and Timed Automata Lynch, Nancy A.; Vaandrager, Frits The timed automaton model of [29, 30] is a general model for timing-based systems. A notion of timed action transducer is here defined as an automata-theoretic way of representing operations on timed automata. It is shown that two timed trace inclusion relations are substitutive with respect to operations that can be described by timed action transducers. Examples are given of operations that can be describe in this way, and a preliminary proposal is given for an appropriate language of operators for describing timing-based systems.

Experience with Fine-grain Synchronization in MIMD Machines for Preconditioned Conjugate Gradient

2023-03-30T03:58:50Z

Experience with Fine-grain Synchronization in MIMD Machines for Preconditioned Conjugate Gradient Yeung, Donald; Agarwal, Anant This paper discusses our experience with fine-grain synchronization for the preconditioned conjugate gradient method using the modified incomplete Cholesky factorization of the coefficient matrix as a preconditioner. This algorithm represents a large class of algorithms that have been widely used but traditionally difficult to implement efficiently on vector and parallel machines. Through a series of experiments conducted using a simulator of a distributed shared-memory multiprocessor, this paper addresses two major questions related to fine-grain synchronization in the context of this application. First, what is the overall impact of fine-grain synchronization on performance? Second, what are the individual contributions of the following three mechanisms typically provided to support fine-grain synchronization: language-level support, full-empty bits for compact storage and communication of synchronization state, and efficient processor operations on the state bits? The experiments indicate that fine-grain synchronization improves overall performance by a factor of 3.7 on 16 processors using the largest problem size we could simulate; the paper also projects that a significant performance advantage will be sustained for larger problem sizes. Preliminary experience shows that the bulk of the performance advantage for this application can be attributed to exposing increased parallelism through language-level expression of fine-grain synchronization. A smaller fraction relies on a compact-implementation of synchronization state, while an even smaller fraction results from efficient full-empty bit operations. The paper also shows that the last two components are likely to have a greater impact on performance as mechanisms for latency tolerance are employed.

Integrating Message-passing and Shared-memory: Early Experience

2023-03-30T03:59:52Z

Integrating Message-passing and Shared-memory: Early Experience Kranz, David; Johnson, Kirk; Agarwal, Anant; Kubiatowicz, John; Lim, Beng-Hong This paper discusses some of the issues involved in implementing a shared-address space programming model on large-scale, distributed-memory multiprocessors. Because message-passing mechanisms are much more efficient than shared-memory loads and stores for certain types of interprocessor communication and synchronization operations, we argue for building multiprocessors that efficiently support both shared-memory and message-passing mechanisms. We describe an architecture, Alewife, that integrates support for shared-memory and message-passing through a simple interface. We expect the compiler and runtime system to cooperate in using appropriate hardware mechanisms that are most efficient for specific operations. We report on both integrated and exclusively shared-memory implementations of our runtime system and one complete application; the final paper will contain results for other applications as well. The integrated runtime system drastically cuts down the cost of communication incurred by the scheduling, load balancing, and certain synchronization operations. We also present some preliminary performance results comparing the two systems.

Hybrid Atomicity for Nested Transactions

2023-03-30T03:02:22Z

Hybrid Atomicity for Nested Transactions Fekete, Alan; Lynch, Nancy A.; Weihl, William E. This paper defines the notion of hybrid atomicity for nested transaction systems, and presents and verifies an algorithm providing this property. Hybrid atomicity is a modular property; it allows the correctness of a system to be deduced from the fact each object is implemented to have the property. It allows more concurrency than dynamic atomicity, by assigning timestamps to transaction at commit. The Avalon system provides exactly this facility.

More Choices Allow More Faults: Set Consensus Problems in Totally Asynchronous Systems

2023-03-30T03:50:44Z

More Choices Allow More Faults: Set Consensus Problems in Totally Asynchronous Systems Chaudhuri, Soma We define k-set consensus problem as an extension of the consensus problem, where each processors decides on a single value such that the set of decided values in any run is of size at most k. We require the agreement condition that all values decided upon are initial values of some processor. We show that the problem has a simple ( k - 1 )-resilient protocol in a totally asynchronous system.

Dribble-Back Registers: A Technique for Latency Tolerance in Multiprocessors

2023-03-30T03:23:20Z

Dribble-Back Registers: A Technique for Latency Tolerance in Multiprocessors Soundararajan, Vijayaraghavan As parallel machines grow in scale and complexity, latency tolerance of synchronization faults and remote memory accesses becomes increasingly important. One method for tolerating this by multithreading the processor and rapidly context switching between these threads. Fast context switching is most effective when the latencies being tolerated are short compared to the total run lengths of all the resident threads.

The Integration of the Organization Engine and Library 2000

2023-03-30T03:27:38Z

The Integration of the Organization Engine and Library 2000 Weiss, Ron In the contemporary research environment, users access and manipulate information gathered from diverse data sources. The organization Engine is a prototype being developed at the Cambridge Research Lab of Digital Equipment Corporation for the incorporation of data from disparate sources into a local homogeneous framework. It relies on information management based on the notion of retrieval and manipulation through the organization of the data in a non strict hierarchical structure.

Approximating the Minimum-cost Maximum Flow is P-Complete

2023-03-30T03:10:14Z

Approximating the Minimum-cost Maximum Flow is P-Complete Stein, Clifford; Wein, Joel We show that it is impossible, in NC, to approximate the value of the minimum-cost maximum flow unless P = NC.

Closing the Window of Vulnerability in Multiphase Memory Transcations

2023-03-30T03:26:58Z

Closing the Window of Vulnerability in Multiphase Memory Transcations Kubiatowicz, John; Chaiken, David; Agarwal, Anant Multiprocessor architects have begun to explore several mechanisms such as prefetching, context-switching and software-assisted dynamic cache-coherence, which transform single-phase memory transactions in conventional memory systems into multiphase operations. Multiphase operations introduce a window of vulnerability in which data can be lost before it is used either through protocol invalidation or cache conflicts. Losing data introduces damaging livelock situations. This paper discusses the origins of the window of vulnerability and proposes an architectural framework that closes it. The framework in implemented in Alwife, a large-scale multiprocessor being built at MIT.

Low-cost Support for Fine-grain Synchronization in Multiprocessors

2023-03-30T03:43:57Z

Low-cost Support for Fine-grain Synchronization in Multiprocessors Kranz, David; Lim, Beng-Hong; Agarwal, Anant As multiprocessors scale beyond the limits of a few tens of processors, they must look beyond traditional methods of synchronization to minimize serialization and achieve the high degrees of parallelism required to utilize large machines. By allowing synchronization at the level of the smallest unit of memory, fine-grain synchronization achieves these goals. Unfortunately, supporting efficient fine-grain synchronization without inordinate amounts of hardware has remained a challenge.

Compile-time Techniques for Processor Allocation in Macro Dataflow Graphs for Multiprocessors

2023-03-30T03:37:22Z

Compile-time Techniques for Processor Allocation in Macro Dataflow Graphs for Multiprocessors Prasanna, G.N. Srinivasa; Agarwal, Anant When compiling a progam consisting of multiple nested loops for execution on a multiprocessor, processor allocation is the problem of determining the number of processors over which to partition each nested loop. This paper presents processor allocation techniques for compiling such programs for multiprocessors with local memory. Programs consisting of multiple loops, where the precedence constraints between the loops is known, can be viewed as macro dataflow graphs. Macro dataflow graphs comprise several macro nodes (or macro operations) that must be executed subject to prespecified precedence constraints. Optimal processor allocation specifies the number of processors computing each macro node and their sequencing to optimize run time. This paper presents computing each macro node and their sequencing to optimize run time. This paper presents computationally efficient techniques for determining the optimal processor allocation using estimated speedup functions of the macro nodes. These ideas have been implemented in a structure-driven compiler, SDC, for expressions of matrix operations. The paper presents the performance of the compiler for several matrix expressions on a simulator of the Alewife multiprocessor.

The Impact of Communication Locality on Large-scale Multiprocessor Performance

2023-03-30T03:45:17Z

The Impact of Communication Locality on Large-scale Multiprocessor Performance Johnson, Kirk L. As multiprocessor sizes scale and computer architects turn to interconnection networks with non-uniform communication latencies, the lure of exploiting communication locality to increase performance becomes inevitable. Models that accurately quantify locality effects provide invaluable insight into the importance of exploiting locality as machine sizes and features change. This paper presents a framework for modeling the impact of communication locality on system performance. The framework provides a means for combining simple models of application, processor, and network behavior to obtain a combined model that accurately reflects feedback effects between processors and networks. We introduce a model that characterizes application behavior with three parameters that capture computation grain, sensitivity to communication latency, and amount of locality present at execution time. The combined model is validated with measurements taken from a detailed simulator for a complete multiprocessor system. Using the combined model, we show that exploiting communication locality provides gains which are at most linear in the factor by which average communication distance is reduced when the number of outstanding communication transactions per processor is bounded. The combined model is also used to obtain rough upper bounds on the performance improvement from exploiting locality to minimize communication distance.

Hierarchical Compilation of Macro Dataflow Graphs for Multiprocessors with Local Memory

2023-03-30T04:09:17Z

Hierarchical Compilation of Macro Dataflow Graphs for Multiprocessors with Local Memory Prasanna, G.N. Srinivasa; Agarwal, Anant; Musicus, Bruce R. This paper presents a hierarchical approach for compiling macro dataflow graphs for multiprocessors with local memory. Macro dataflow graphs comprise several nodes (or macros operations) that must be executed subject to prespecified precedence constraints. Programs consisting of multiple nested loops, where the precedence constraints between the loops are known, can be viewed as macro dataflow graphs. The hierarchical compilation approach comprises a processor allocation phase followed by a partitioning phase. In the processor allocation phase, using estimated speedup functions for the macro nodes, computationally efficient techniques establish the sequencing and parallelism of macro operations for close-to-optimal run times. The second phase partitions the computations in each macro node to maximize communication locality for the level of parallelism determined by the processor allocation phase. The same approach can also be used for programs consisting of multiple loop nests, when each of the nested loops can be characterized by a speedup function. These ideas have been implemented in a prototype structure-driven compiler, SDC, for expressions of matrix operations. The paper presents the performance of the compiler for several matrix expressions on a simulator of the Alewife multiprocessor.

Memory Assignment for Multiprocessor Caches Through Graph Coloring

2023-03-30T03:35:05Z

Memory Assignment for Multiprocessor Caches Through Graph Coloring Agarwal, Anant; Guttag, John; Papaefthymiou, Marios It has become apparent that the achieved performance of multiprocessors is heavily dependent upon the quality of the availabel compilers. In this paper we are concerned with compile-time techniques that can be used to achieve better performance by improving cache utilization. Specifically, we investigate the problem of assigning data chunks to memory in a way that will minimize collisions in direct-mapped multiprocessor caches. We show that while this problem is computationally intractable, there are interesting special cases that can be solved in polynomial time. We also present several techniques that can be used when conflict-free assignment is not possible, or when finding a conflict-free assignment is computationally infeasible. These techniques include uniform decaching, which involves not caching specific data blocks, and data replication, which involves making multiple copies of read-only data. Finally, we present a memory assigment technique, grey coloring, that reduces latency in the presence of collisions by distributing cache misses among processors in a way that minimized the total number of cache misses in any specific cache.

Hierarchical Compilation of Macro Dataflow Graphs for Multiprocessors with Local Memory

2023-03-30T04:07:10Z

The Impact of Communication Locality on Large-scale Multiprocessor Performance

2023-03-30T04:25:31Z

An Analysis of Rabin's Randomized Mutual Exclusion Algorithm: Preliminary Report

2023-03-30T03:52:18Z

An Analysis of Rabin's Randomized Mutual Exclusion Algorithm: Preliminary Report Lynch, Nancy A.; Saias, Isaac In 1982, Michael Rabin published a randomized distributed algorithm implementing mutual exclusion for n processes using a read-modify-write primitive on a shared variable with O(log n) values. He claimed that this algorithm satisfied the following informally-stated strong probabilistic no-lockout property. Define the adversary to be the entity controlling the order in which processes take steps; then, for every adversary, any process competing for entrance to the critical section succeeds with probability Ω(1/m), where m is the number of competing processes. In this paper we consider several different ways in which this property can be expressed formally. We express explicitly the dependency of the probability on the adversary and show that this dependency is so strong that the algorithm does not satisfy any of these conditions. In fact, the algorithm does not even satisfya much weaker Ω(1/n) property.

Fast Deterministic Constructions of Low-Diameter Network Decompositions

2023-03-30T03:12:53Z

Fast Deterministic Constructions of Low-Diameter Network Decompositions Berger, Bonnie; Cowen, Lenore

Linearizable Counting Networks

2023-03-30T03:20:47Z

Linearizable Counting Networks Merlihy, Maurice; Shavit, Nir; Waarts, Orli The counting problem requires n asynchronous processors to assign themselves successive values. A solution is linearizable if the order of the values assigned reflects the real-time order in which they were requested. Linearizable counting lies at the heart of concurrent timestamp generation, as well as concurrent implementations of shared counters, FIFO buffers, and similar data structures. We consider solutions to the linearizable counting problem in a multiprocessor architecture in which processors communicate by applying read-modify-write operations to a shared memory. Linearizable counting algorithms can be judged by three criteria: the memory contention produced, whether processors are required to wait for one another, and how long it takes a processor to choose a value (the latency). A solution is ideal if it has low contention, low latency, and it eschews waiting. The conventional software solution, where processors synchornize at a single variable, avoids waiting and has low latency, but has high contention. In this paper we give two new counting network constructions, one with low latency and low contention, but that requires processors to wait for one another, and one with low contention and no waiting, but that has high latency. Finally, we prove that these trade-offs are inescapable: an ideal linearizable counting algorithm is impossible. Since ideal non-linearizable counting algorithms exist, these results establish a substantial complexity gap between linearizable and non-linearizable counting.

Forward and Backward Simulations for Timing-based Systems

2023-03-30T03:15:22Z

Forward and Backward Simulations for Timing-based Systems Lynch, Nancy A.; Vaandrager, Frits A general automaton model for timing-based systems is presented and is used as the context for developing a variety of simulation proof techniques for such systems. As a first step, a comprehensive overview of simulation techniques for simple untimed automata is given. In particular, soundness and completeness results for (1) refinements, (2) forward and backward simulations, (3) forward-backward and backward-forward simulations, and (4) history and prophecy relations are given.

An Algorithm for the Tramp Steamer Problem Based on Mean-weight Cycles

2023-03-30T03:12:13Z

An Algorithm for the Tramp Steamer Problem Based on Mean-weight Cycles Ishii, Alexander T.; Leiserson, Charles E.; Papaefthymiou, Marios C.

Replication in the Harp File System

2023-03-30T04:24:58Z

Replication in the Harp File System Liskov, B.; Ghemawat, S.; Gruber, R.; Johnson, P.; Shrira, L.; Williams, M. This paper describes the design and implementation of the Harp file system. Harp is a replicated Unix file system accessible via the VFS interface. It provides highly available and reliable storage for files and guarantees that file operations are executed atomically in spite of concurrency and failures. It uses a novel variation of the primary copy replication technique that provides good performance because it allows us to trade disk accesses for network communication. Harp is intended to be used within a file service in a distributed network; in our current implementation, it is accessed via NFS. Preliminary performance results indicate that Harp provides equal or better response time and system capacity than an unreplicated implementation of NFS that uses Unix files directly.

A Fast Multiport Memory Based on Single-port Memory Cells

2023-03-30T04:02:07Z

A Fast Multiport Memory Based on Single-port Memory Cells Rivest, Ronald L.; Glasser, L. We present a new design for dual-port memories that uses single-port memory cells but guarantees fast deterministic read/write access. The basic unit of storage is the word, rather than the bit, and addresses conflicts result in bit errors that are removed by correction circuitry. The addressing scheme uses Galois field arithmetic to guarantee that the maximum number of bit errors in any word accessed is one. These errors can be corrected every time with a simple correction scheme. The scheme can be generalized to an arbitrary number of ports.

The MIT Alewife Machine: A Large-scale Distributed-memory Multiprocessor

2023-03-30T03:27:46Z

The MIT Alewife Machine: A Large-scale Distributed-memory Multiprocessor Agarwal, Anant; Chaiken, David; Johnson, Kirk; Kranz, David; Kubiatowicz, John; Kurihara, Kiyoshi; Lim, Beng-Hong; Maa, Gino; Nussbaum, Dan The Alewife multiprocessor project focuses on the architecture and design of a large-scale parallel machine. The machine uses a low dimension direct interconnection network to provide scalable communication band-width, while allowing the exploitation of locality. Despite its distributed memory architecture, Alewife allows efficient shared memory programming through a multilayered approach to locality management. A new scalable cache coherence scheme called LimitLess directories allows the use of caches for reducing communication latency and network bandwidth requirements.

Cost-sensitive Analysis of Communication Protocols

2023-03-30T03:26:03Z

Cost-sensitive Analysis of Communication Protocols Awerbuch, Baruch; Baratz, Alan; Peleg, David This paper introduces the notion of cost-sensitive communication complexity and exemplifies it on the following basic communication problems: computing a global function, network synchornization, clock synchronization, controlling protocols' worst-case execution, connected components, spanning tree, etc., contructing a minimymn spanning tree, constructing a shortest path tree.

The Complexity of Continuous Optimization

2023-03-30T04:15:50Z

The Complexity of Continuous Optimization Rogaway, Phillip Given a polynomial objective function f(x1,…,xn), we consider the problem of finding the maximum of this polynomial inside some convex set D = {x : Ax <= B}. We show that, under a complexity assumption, this extremum cannot be approximated by any polynomial-time algorithm, even exceedingly poorly. This represents an unusual interplay of discrete and continuous mathematics: using a combinatorial argument to get a hardness result for a continuous optimization problem.

Counting Networks

2023-03-30T04:05:30Z

Counting Networks Aspnes, James; Herlihy, Maurice; Shavit, Nir Many fundamental multi-processor coordination problems can be expressed as counting problems: processes must cooperate to assign successive values from a given range, such as addresses in memory of destinations on an interconnection network. Conventional solutions to these problems perform poorly because of synchronization bottlenecks and high memory contention. Motivated by observations on the behavior of sorting networks, we offer a completely new approach to solving such problems. We introduce a new class of networks called counting networks, i.e., networks that can be used to count. We give two counting network constructions of depth log^2 n, using n log^2 n "gates," avoiding the sequential bottlenecks inherent to former solutions, and substantially lowering the memory contention. Finally, to show that counting networks are not merely mathematical creatueres, we provide experimental evidence that they outperform conventional synchronization techniques under a variety of circumstances.

APRIL: A Processor Architecture for Multiprocessing

2023-03-30T03:52:58Z

APRIL: A Processor Architecture for Multiprocessing Agarwal, Anant; Lim, Beng-Hong; Kranz, David; Kubiatowicz, John Processors in large-scale multiprocessors must be able to tolerate large communication latencies and synchronization delays. This paper describes the architecture of a rapid-context-switching processor called APRIL with support for fine-grain threads and synchronization. APRIL achieves high single-thread performance and supports virtual dynamic threads. A commercial RISC-based implementation of APRIL and a run-time software system that can switch contexts in about 10 cycles is described. Measurements taken for several parallel applications on an APRIL simulator show that the overhead for supporting parallel tasks based on futures is reduced by a factor of two over a corresponding implementation on the Encore Multimax. The scalability of a multiprocessor based on APRIL is explored using a performance model. We show that the SPARC-based implementation of APRIL can achieve close to 80% processor utilization with as few as three resident threads per processor in a large-scale cache-based machine with an average base network latency of 55 cycles.

Lazy Task Creation: A Technique for Increasing the Granularity of Parallel Programs

2023-03-30T04:10:32Z

Lazy Task Creation: A Technique for Increasing the Granularity of Parallel Programs Mohr, Eric; Kranz, David; Halstead; Robert H., Jr. Many parallel algorithms are naturally expressed at a fine level of granularity, often finer than MIMD parallel system can exploit efficiently. Most builders of parallel systems have looked to either the programmer or a parallelizing compiler to increase the granularity of such algorithms. In this paper we explore a third approach to the granularity problem by analyzing two strategies for combining parallel tasks dynamically at run-time.

Limitless Directories: A Scalable Cache Coherence Scheme

2023-03-30T04:06:28Z

Limitless Directories: A Scalable Cache Coherence Scheme Chaiken, David; Kubiatowicz, John; Agarwal, Anant Caches enhance the performance of multiprocessors by reducing network traffic and average memory access latency. However, cache-based systems must address the problem of cache coherence. We propose the LimitLESS directory protocol to solve this problem. The LimitLESS scheme uses a combination of hardware and software techniques to realize the performance of full-map directory with the memory overhead of limited directory. This protocol is supported by Alewife, a large-scale multiprocessor. We describe the architectural interfaces needed to implement the LimitLESS directory, and evaluate its performance though simulations of the Alewife machine.

Reliable Communication Over Unreliable Channels

2023-03-30T04:01:24Z

Reliable Communication Over Unreliable Channels Afek, Yehuda; Attiya, Hagit; Fekete, Alan; Fischer, Michael; Lynch, Nancy A.; Mansour, Yishay; Wang, Da-Wei; Zuck, Lenore Layered communication protocols frequently implement a FIFO message facility on top of an unreliable non-FIFO service such as that provided by a packet-switching network. This paper investigates the possibility of implementing a reliable message layer on top of an underlying layer that can lose packets and deliver them out of order, with the additional restriction that the implementation uses only a fixed finite number of different packets. A new formalism is presented to specify communication layers and their properties, the notion of their implementation by I/O automata, and the properties of such implementations. An I/O automaton that implements a reliable layer over an unreliable layer is presented. In this implementation, the number of packets needed to deliver each succeeding message increases permanently as additional packet-loss and reordering faults occur. A proof is given that no protocol can avoid such performance degradation.

An Autoimmune Mechanism for AIDS' T4 Lymphopenia

2023-03-30T14:52:51Z

The Complexity of Decision Versus Search

2023-03-30T03:58:10Z

The Complexity of Decision Versus Search Bellare, Mihir; Goldwasser, Shafi A basic question about NP is whether or not search (the problem of finding a witness) reduces in polynomial time to decision ( the problem deciding whether there exists a witness). The fact that search does reduce to decision for SAT and other NP-complete problems (self-reducibility) is among the most well known facts in the theory of computation. But the general question of whether search reduces to decision for every language in NP remains open. We indicate that the answer is negative: under a natural complexity assumption (that deterministic and non deterministic double exponential time are unequal) we construct a language in NP for which search does not reduce to decision.

An Autoimmune Mechanism for AIDS' T4 Lymphopenia

2023-03-30T04:01:18Z

Are Wait-free Algorithms Fast?

2023-03-30T03:35:18Z

Are Wait-free Algorithms Fast? Attiya, Hagit; Lynch, Nancy A.; Shavit, Nir The time complexity of wait-free algorithms in "normal" executions, where no failures occure and processes operate at approximately the same speed, is considered. A lower bound of log n on the time complexity of any wait-free algorithm that achieves approximate agreements among n processes is proved. In contrast, there exists a non-wait-free algorithm that solves this problem in constant time. This implies an Ω(log n) time separation between the wait-free and non-wait-free computation models. On the positive side, we present an O(log n) time wait-free approximate agreement algorithm; the complexity of this algorithm is within a small constant of the lower bound.

On-line Algorithms for 2-coloring Hypergraphs via Chip Games

2023-03-30T03:04:31Z

On-line Algorithms for 2-coloring Hypergraphs via Chip Games Aslam, Javed A.; Dhagat, Aditi

On the Massively Parallel Solution of The Assignment Problem

2023-03-30T03:18:51Z

On the Massively Parallel Solution of The Assignment Problem Wein, Joel; Zenios, Stavros In this paper we discuss the design, implementation and effectiveness of massively parallel algorithms for the solution of large-scale assignment problems. In particular, we study the auction algorithm of Bertsekas, an algorithm based on the method of multipliers of Hestenes and Powell, and an algorithm based on the alternating direction method of multipliers of Eckstein. We discuss alternative approaches to the massively parallel implementation of the auction algorithm, including Jacobi, Gauss-Seidel and a hybrid scheme. The hybrid scheme, in particular, exploits two different levels of parallelism and an efficient way of communicating the data between them without the need to perform general router operations across the hypercube network. We then study the performance of massively parallel implementations of the two methods of multipliers. Implementations are carried out on the Connection Machine CM-2, and the algorithms are evaluated empirically with the solution of large scale problems. The hybrid scheme significantly outperforms all of the other methods and gives the best computational results to date for a massively parallel solution to this problem.

On-line Scheduling of Parallel Machines

2023-03-30T03:58:03Z

On-line Scheduling of Parallel Machines Wein, Joel; Williamson, David P. We study the problem of scheduling jobs on parallel machines in an on-line fashion, where the processing requirement of a job is not known until the job is completed. Despite this lack of knowledge of the future, we wish to schedule so as to minimize the completion time of the entire set of jobs. In general, the performance of an on-line algorithm is measured by its competitive ratio: the worst case ratio of its performance of an optimal algorithm with total prior knowledge. We study two fundamental models for this problem, that of identical machines, where all the machines run at the same speed, and uniformaly related machines, where the machines run at different speeds. Our results include: 1) Matching upper and lower bounds on the competitive ratio for the case of identical machines. 2) Upper and lower bounds that differ by a constant factor for uniformly related machines. 3) A lower bound for randomized algorithms for identical machines that nearly matches the deterministic upper bound. 4) Several upper and lower bounds for variations on these models.

Bounds on the Time to Reach Agreement in the Presence of Timing Uncertainty

2023-03-30T03:59:10Z

Bounds on the Time to Reach Agreement in the Presence of Timing Uncertainty Attiya, Hagit; Dwork, Cynthia; Lynch, Nancy A.; Stockmeyer, Larry

The MD4 Message Digest Algorithm

2023-03-30T03:45:49Z

The MD4 Message Digest Algorithm Rivest, Ronald L. The MD4 message digest algorithm takes an input message of arbitrary length and produces an output 128-bit "fingerprint" or "message digest," in such a way that it is (hopefully) computationally infeasible to produce two messages having the same message digest, or to produce any message having a given prespecified target message digest. The MD4 algorithm is thus ideal for digital signature applications: a large file can be securely "compressed" with MD4 before being signed with (say) the RSA public-key cyrptosystem. The MD4 algorithm is designed to be quite fast on 32-bit machines. For example, on a SUN Sparc station, MD4 runs at 1,450,000 bytes/second (11.6 Mbit/sec). In addition, the MD4 algorithm does not require any large substitution tables; the algorithm can be coded quite compactly. The MD4 algorithm is being place in the public domain for review and possible adoption as a standard.

Randomness-efficient Sampling of Arbitrary Functions

2023-03-30T14:23:36Z

Randomness-efficient Sampling of Arbitrary Functions Bellare, Mihir; Rompel, John

How to Sign Given Any Trapdoor Permutation

2023-03-30T03:57:21Z

How to Sign Given Any Trapdoor Permutation Bellare, Mihir; Micali, Silvio We present a digital signature scheme which is based on the existence of any trapdoor permutation. Our scheme is secure in the strongest possible natural sense: namely, it is secure against existential forgery under adaptive chosen message attack.

Atomic Snapshots of Shared Memory

2023-03-30T04:07:00Z

Atomic Snapshots of Shared Memory Afek, Yehuda; Attiya, Hagit; Dolev, Danny; Gafni, Eli; Merritt, Michael; Shavit, Nir

Modelling Shared State in a Shared Action Model

2023-03-30T03:01:51Z

Modelling Shared State in a Shared Action Model Goldman, Kenneth; Lynch, Nancy A.

Non-ontrusive Synchonizers

2023-03-30T03:51:04Z

Non-ontrusive Synchonizers Awerbuch, Baruch; Peleg, David

Workstation Services and Kerberos Authentication at Project Athena

2023-03-30T03:11:20Z

Workstation Services and Kerberos Authentication at Project Athena Davis, Don; Swick, Ralph This document proposes solutions for two problems obstructing Project Athena's implementation of workstation services. The principal problem is that workstation services demand a more flexible mutual-authentication protocol than Kerberos currently provides. The egregious X access-control hack, xhost, for example, has lack of authentication as its root cause. The protocol weakness is also the reason that public workstations can't accept authenticated connections from rlogin, rcp, rsh, etc. We propose an extension to the Kerberos Ticket Granting Service protocol, that cleanly supports user-to-user mutual authentication. Our second proposal addresses the problem of ticket propagation. Currently, if a user wants tickets that are valid on a remote host, he has to run kinit an encrypted login session, unless he's willing to send his password in cleartext. As an example of the use of our protocol extension, we describe a Kerberos application that would support a limited facility for secure ticket-propagation.

Sharing Memory Robustly in Message-passing Systems

2023-03-30T04:09:12Z

Sharing Memory Robustly in Message-passing Systems Attiya, Hagit; Bar-Noy, Amotz; Dolev, Danny

Multivalued Possibilities Mappings

2023-03-30T04:21:53Z

Multivalued Possibilities Mappings Lynch, Nancy A. Abrastraction mappings are one of the major tools used to construct correctness proofs for concurrent algorithms. Several examples are given of situations in which it is useful to allow the abstraction mappings to be multivalued. The examples involve algorithm optimization, algorithm distribution, and proofs of time bounds.

Stochastic Analysis of Qualitative Dynamics

2023-03-30T03:08:04Z

Stochastic Analysis of Qualitative Dynamics Doyle, Jon; Sacks, Elisha P.

Synthesis of Efficient Drinking Philosphers Algorithms

2023-03-30T14:20:21Z

Synthesis of Efficient Drinking Philosphers Algorithms Welch, Jennifer Lundelius; Lynch, Nancy A. A variant of the drinking philosphers algorithm of Chandy and Misra is described and proved correct in a module way, using the I/O automaton model of Lynch and Tuttle. The algorithm of Chandy and Misra is based on an particular dining philosophers algorithm, and relies on certain properties of its implementation. The drinking philosophers algorithm presented in this paper is able to use an arbitrary dining philosophers algorithm as a true subroutine; nothing about the implementation needs to be known, only that is solves the dining philosophers problem. An important advantage of this modularity is that by substituting a more time-efficient dining philosophers algorithm with O(1) worst-case waiting time is obtained, whereas the drinking philosophers algorithm of Chandy and Misra has O(n) worst-case waiting time (for n philosophers). Formal definitions are given to distinguish the drinking and dining philosophers problems and to specify precisely varying degrees of concurrency.

Impediments to Universal Preference-based Default Theories

2023-03-30T03:43:21Z

Impediments to Universal Preference-based Default Theories Doyle, Jon; Wellman, Michael Research on nonmonotonic and default reasoning has identified several important criteria for preferring alternative default inferences. The theories of reasoning based on each of these criteria may uniformly be viewed as theories of rational inference, in which the reasoner selects maximally preferred states of belief. Though researchers have noted some cases of apparent conflict between the preferences supported by different theories, it has been hoped that these special theories of reasoning may be combined into a universal logic of nonmonotonic reasoning. We show that the different categories of preferences conflict more than has been realized, and adapt formal results from social choice theory to prove that every universal theory of default reasoning will violate at least one reasonable principle of rational reasoning. Our results can be interpreted as demonstrating that, within the preferential framework, we cannot expect much improvement on the rigid lexicographic priority mechanisms that have been proposed for conflict resolution.

Routing with Polynomial Communication-space Tradeoff

2023-03-30T03:05:24Z

Routing with Polynomial Communication-space Tradeoff Awercuch, Baruch; Peleg, David

Online Tracking of Mobile Users

2023-03-30T03:37:46Z

Online Tracking of Mobile Users Awercuch, Baruch; Peleg, David This paper deals with the problem of maintaining a distributed directory server, that enables us to keep track of mobile users in a distributed network. The paper introduces the graph-theoretic concept of regional matching, and demonstrates how fining a regional matching with certain parameters enables efficient tracking. A polynomial-time algorithm that constructs such a regional matching is presented. The communication overhead of our tracking mechanism is within a polylogarithmic factor of the lower bound.

Nnuclear Fusion Through Dimensional Confinement

2023-03-30T03:42:50Z

Nnuclear Fusion Through Dimensional Confinement Smith, Mark A. A formal mechanism for enhancing nnuclear fusion rates is proposed. The enhancement results whenever the reacting nuclei preferentially migrate in a restricted subspace of phase space - in particular, a fractal subspace. An extended Lawsom criterion is derived, and the prospects for this mechanism in condensed matter are discussed.

Theory of Computation Group Research Summary June 1988 - July 1989

2023-03-30T03:26:48Z

Theory of Computation Group Research Summary June 1988 - July 1989 Theory of Computation Group

Time Bounds for Real-time Process Control in the Presence of Time Uncertainty

2023-03-30T03:25:31Z

Time Bounds for Real-time Process Control in the Presence of Time Uncertainty Attiya, Hagit; Lynch, Nancy A.

A Hundred Impossibility Proofs for Distributed Computing

2023-03-30T03:52:16Z

A Hundred Impossibility Proofs for Distributed Computing Lynch, Nancy A.

Type Abstraction Rules for References: A Comparison of Four Which have Achieved Notoriety

2023-03-30T03:42:41Z

Type Abstraction Rules for References: A Comparison of Four Which have Achieved Notoriety O'Toole Jr., James William I present four type abstraction rules which have been introduced by various authors to permit polymorphic type safety in the presence of mutable data. each of the type abstraction rules is discussed in the context of the language in which is was introduced, and the various abstraction rules are compared.

Three Methods for Range Queries in Computational Geometry

2023-03-30T03:11:28Z

Three Methods for Range Queries in Computational Geometry Kipnis, Shlomo This paper surveys a variety of recent results addressing the problem of range queries in computational geometry. The major contribution of this paper is in identifying three general methods for range queries in computational geometry and in classifying many of the recent results into one or more of these approaches. The three methods discussed in this paper are random sampling, search-tree tables, and space-partition trees. This survey assumes some familiarity with basic computational geometry concepts and techniques.

Communication Effects for Message-based Concurrency

2023-03-30T03:06:05Z

Communication Effects for Message-based Concurrency Jouvelot, Pierre; Gifford, David K. We describe a new framework for explicity concurrency that uses an effect system to describe the communication behavior of expressions in a typed polymorphic programming language. Concurrency occurs between processes connected by channels on which messages are transmitted. Communication operations are characterized by two communication effect constructors, out and in, depending on whether a message has been sent or received. Synchronization is only allowed by message passing along shared channels; communication via mutation of global variables is staticially prohibited by our communication effect system, thus restricting the amount of non-determinancy in user programs. Unobservable communication effects can be masked by the effect system. We show that this system is powerful enough to express many other parallel paradigms, like systolic arrays or pipes, in a typed framework. The programmer can thus express concurrency in a rather flexible way while preserving the correctness of implicit detection of parallelism and optimization by the compiler. This new concurrency framework has been implemented in the FX-87 programming language.

Natural Random Numbers

2023-03-30T03:08:15Z

Natural Random Numbers Gofford, David K. We present a method for generaing random numbers from natural noise sources that is able to produce random numbers to any desired level of perfection. The method works by transducing a physical noise source to generate a stream of biased natural bits, and then applying an unbiasing algorithm. The Wiener-Kinchine relation is used to derive the autocorrelation present in the stream of biased bits and to define safe sampling rate. Experimental results from an implementation of our method support our analysis. One consequence of our analysis is that a broad class of natural random number generators, including ours, can not generate absolutely perfect random numbers.

A Lattice-structured Proof Technique Applied to a Minimum Spanning Tree Algorithm

2023-03-30T04:13:49Z

A Lattice-structured Proof Technique Applied to a Minimum Spanning Tree Algorithm Welch, Jennifer Lundelius; Lamport, Leslie; Lynch, Nancy A. Higly-optimized concurrent algorithms are often hard to prove correct because they have no natural decomposition into separately provable parts. This paper presents a proof technique for the modular verification of such non-modular algorithms. It generalizes existing verification techniques based on a totally-ordered hierarchy of refinements to allow a partially-ordered hierarchy - that is, a lattice of different views of the algorithm. The technique is applied to the well-known distributed minimum spanning tree algorithm of Gallager, Humblet, and Spira, which has until recently lacked a rigorous proof.

Combinatorial Algorithms for the Generalized Circulation Problem

2023-03-30T03:08:50Z

Combinatorial Algorithms for the Generalized Circulation Problem Goldberg, Andrew V.; Plotkin, Serge A.; Tardos, Eva We consider a generalization of the maximum flow problem in which the amounts of flow entering and leaving an arc are linearly related. More precisely, if x(e) units of flow enter an arc e, x(e) ?(e) units arrive at the other end. For instance, nodes of the graph can correspond to different currencies, with the multipliers being the exchange rates. We require conservation of flow at every node except a given source node. The goal is to maximize the amount of flow excess at the source. This problem is a special case of linear programming, and therefore can be solved in polynomial time. In this paper we present the first polynomial time combinatorial algorithms for this problem. The algorithms are simple and intuitive.

Sublinear-time Parallel Algorithms for Matching and Related Problems

2023-03-30T04:14:36Z

Sublinear-time Parallel Algorithms for Matching and Related Problems Goldberg, Andrew V.; Plotkin, Serge A.; Vaidya, Pravin This paper presents the first sublinear-time deterministic parallel algorithms for bipartite matching and several related problems, including maximal node-disjoint paths, depth-first search, and flows in zero-one networks. Our results are based on a better understanding of the combinatorial structure of the above problems, which leads to new algorithmic techniques. In particular, we show how to use maximal matching to extend, in parallel, a current set of node-disjoint paths and how to take advantage of the parallelism that aries when a large number of nodes are "active" during an execution of a push/relabel network flow algorithm. We also show how to apply our techniques to design parallel algorithms for the weighted versions of the above problems. In particular, we present sublinear-time deterministic parallel algorithms for finding a minimum-weight bipartite matching and for finding a minimum-cost flow in a network with zero-one capacities, if the weights are polynomially bounded integers.

Semantical Paradigms: Notes for an Invited Lecture

2023-03-30T03:59:35Z

Semantical Paradigms: Notes for an Invited Lecture Meyer, Albert R.; Cosmadakis, Stavros S. It tooke me quite a few years to understand the point of the continuity in denotational semantics. I'm happy to report below on some recent results which justify my muddle-headedness and help to explain the point too. What follows are some global comments on denotational semantics of teh kinds invited lecturers sometimes indulge themselves in, highlighting "goodness of fit" criteria between semantic domains and symbolic evaluators. For readers impatient with sketchy overviews, two appendices mostly by Cosmadakis provide the key parts of a long proof that Scott domains give a computationally adequate and fully abstract semantics for lambda calculus with simple recursive types.

I/O Automata: A Model for Discrete Event Systems

2023-03-30T03:26:14Z

I/O Automata: A Model for Discrete Event Systems Lynch, Nancy A.

A Modular Proof of Correctness for a Network Synchronizer

2023-03-30T04:23:22Z

A Modular Proof of Correctness for a Network Synchronizer Fekete, A.; Lynch, N.; Shrira, L. In this paper we offer a formal, rigorous proof of the correctness of Awerbuch's algorithm for network synchronization. We specify both the algorithm and the correctness condition using the I/O automaton model, which has previously been used to describe and verify algorithms for concurrency control and resource allocation. We show that the model is also a powerful tool for reasoning about distributed graph algorithmss. Our prood of correctness follows closely the intuitive arguments made by the designer of the algorithm by exploiting the model's natural support for such important design techniques as stepwise refinement and modularity. In particular, since the algorithm uses simpler algorithms for synchronization within and between "clusters" of nodes, our prood can import as lemmas the correctness of these simpler algorithms.

Inferring Decision Trees Using the Minimum Description Length Principle

2023-03-30T04:21:26Z

Inferring Decision Trees Using the Minimum Description Length Principle Quinlan, L. Ross; Rivest, Ronald L. We explore the use of Rissanen's Minimum Description Length Principle for the construction of decision trees. Empirical results comparing this approach to other methods are given.

Lower Bounds for Recognizing Small Cliques on CRCW PRAM's

2023-03-30T03:05:01Z

Lower Bounds for Recognizing Small Cliques on CRCW PRAM's Beame, Paul

The Semantics of Miranda's Algebraic Types

2023-03-30T03:43:28Z

The Semantics of Miranda's Algebraic Types Bruce, Kim B.; Riecker, Jon G. Miranda has two interesting features in its typing system: implicit polymorphism (also known as ML-style polymorphism) and algebraic types. Algebraic types create new types from old and can operate on arbitrary types. This paper argues that functions of types, or type constructors, best represent the meaning of algebraic types. Building upon this idea, we develop a denotational semantics for algebraic types. We first define a typed lambda calculus that specifies type constructors. A semantic model of type constructors is them built, using the ideal model as a basis. (The ideal model gives the most natural semantics for Miranda's implicit polymorphism.) The model is shown to be sound with respect to this lambda calculus. FInally, we demonstrate how to use the model to interpret algebraic types, and prove that the translation produces elements in the model.

Finding Minimum-cost Circulations by Canceling Negative Cycles

2023-03-30T03:35:34Z

Finding Minimum-cost Circulations by Canceling Negative Cycles Goldberg, Andrew V.; Tarjan, Robert E. A classical algorithm for finding a minimum-cost circultaion consists of repeatedly finding a residual cycle of negative cost and canceling it by pushing enough flow around the cycle to saturate an arc. We show that a judicious choice of cycles for canceling leads to a polynomial bound on the number of iterations in this algorithm. This gives a very simple strongly polynomial algorithm that uses no scaling. A variant of the algorithm that uses dynamic trees runs in O(nm(log n)min{log(nC),mlogn}) time on a network of n verticies, m arcs, and arc costs of maximum absolute value C. This bound is comparable to those of the fastest previously known algorithms.

Finding Minimum-cost Circulations by Successive Approximation

2023-03-30T03:33:11Z

Finding Minimum-cost Circulations by Successive Approximation Goldberg, Andrew V.; Tarjan, Robert E.

Formulation of Tradeoffs in Planning Under Uncertainty

2023-03-30T03:53:48Z

Formulation of Tradeoffs in Planning Under Uncertainty Wellman, Michael P. Planning under uncertainty with multiple, competing objectives is impossible when goals are represented as predicates and the effects of actions are modeled as deterministic functions of situations. Decision-theoretic models, on the other hand, do not address the problem of constructing strategies from more primitive representations of actions. In this proposal, I describe a method for formulating plans from large knowledge bases that can accomodate uncertain and partial satisifaction of goals. At the core of the planner is a dominance prover that derives admissibility properties of plan classes. The representation for the effects of actions is based on a qualitative formalism for asserting influences among variables. The planner makes decisions "up to tradeoffs," an intuitive description that seems to characterize the power of a dominance prover based on the qualitative influence formalism.

Controlling Worst-case Performance of a Communication Protocol and Dynamic Resource Management

2023-03-30T04:04:22Z

Controlling Worst-case Performance of a Communication Protocol and Dynamic Resource Management Awerbuch, Baruch This paper raises a fundamental questions, neglected so far in the literature: how to make a distributed algorithm robust against input errors and wrong probabilistic assumptions about the distribution of the inputs or of the link delays. We introduce a notion of complexity-preserving protocol controller: this is an automatic procedure that controls worst-case execution of any distributed algorithm. We then suggest a controlled with poly-logarithmic overhead. We show that the problem of designing controllers is a special case of another problem, referred to as dynamic resource management. We generalize our solution to solve the latter problem. We believe that the techniques used are basic ones, and will be used to solve a variety of unrelated network problems. Our solution seems to be very practical, since the formal code of the protocol is very simple and thus easy to implement. The technique used in the solution appears to be interesting because a global resource is manipulated locally. This somewhat resembles the "parallel prefix" technique used extensively in parallel computing.

A Space-efficient Algorithm for Finding the Connected Components of Rectangles in the Plane

2023-03-30T03:48:20Z

A Space-efficient Algorithm for Finding the Connected Components of Rectangles in the Plane Leiserson, Charles E.; Phillips, Cynthia A. We present an algorithm for determining the connectivity of a set of N rectangles in the plane, a problem central to avoiding aliasing in VLSI design rule checkers. Previous algorithms for this problem either worked slowly with a small amount of primary memory space, or worked quickly but used more space. Our algorithm uses O(W) primary memory space, where W, the scan width, is the maximum number of rectangles to cross any vertical cut. The algorithm runs in O(N lg N) time and requires no more than O(N) transfers between primary and secondary memory.

Efficient Multichip Partial Concentrator Switches

2023-03-30T03:53:31Z

Efficient Multichip Partial Concentrator Switches Cormen, Thomas H.

Efficient Parallel Algorithms for (_+1)-coloring and Maximal Indepdendent Set Problems

2023-03-30T04:01:27Z

Efficient Parallel Algorithms for (_+1)-coloring and Maximal Indepdendent Set Problems Goldberg, Andrew V.; Plotkin, Serge A. We describe an efficient technique for breaking symmetry in paralle. The technique works especially well on rooted trees and on graphs with a small maximum degree. In particular, we can find a maximal independent set on a constant-degree graph in O(lg*n) time on an EREW PRAM using a linear number of processors. We show how to apply this technique to construct more efficient paralle algorithms for several problems, including coloring of planar graphs and (Δ+1)-coloring of constant-degree graphs. We also prove lower bounds for two related problems.

Murmur Clinic: An Auscultation Expert System

2023-03-30T03:38:27Z

Murmur Clinic: An Auscultation Expert System Leong, Tze-Yun Auscultation is a technique used in cardiac physical examination to detect irregularities by analyzing heart sounds. This paper reports on the development of Murmur Clinic, a cardiac auscultation expert system which is able to interpret and analyze auscultatory findings, and performs a tentative diagnosis based on a formalized diagnostic reasoning process. Descriptions of the scope addressed, the design, the diagnostic algorithm used and implementation of the system, as well as a sample session, and a discussion of limitations and possible improvements are presented.

Communication-efficient Parallel Graph Algorithms

2023-03-30T03:33:26Z

Communication-efficient Parallel Graph Algorithms Leiserson, Charles E.; Maggs, Bruce M. Communication bandwidth is a resource ignored by most parallel random-access machine (PRAM) models. This paper shows that many graph problems can be solved in parallel, not only with polylogarithmic performance, but with efficient communication at each step of the computation. We measure the communication requirements of an algorithm in a model called the distributed random-access machine (DRAM), in whcih communication cost is measured in terms of the congestion of memory access across cuts of an underlying network. The algorithms are based on a communication-efficient variant of the tree contraction technique due to Miller and Reif.

Cellular Automata '86 Conference

2023-03-30T03:58:07Z

Cellular Automata '86 Conference Bennett, Charles H.; Toffoli, Tommaso; Wolfram, Stephen

Data Sharing in Group Work

2023-03-30T03:11:01Z

Data Sharing in Group Work Greif Irene; Sarin, Sunil Data sharing is fundamental to computer-supported cooperative work: people share information through explicit communication channels and through their coordinated use of shared databases. Database support tools are therefore critical to the effective implementation of software for group work. This paper survey data sharing requirements for grouop work, highlight new database technologies that are especially likely to affect our ability to build computer systems supporting group work.

Atomic Shared Register Access by Asynchronous Harward

2023-03-30T03:48:00Z

Atomic Shared Register Access by Asynchronous Harward Vitányi, Paul M.B.; Awerbuch, Baruch The contribution of this paper is two-fold. First, we describe two ways to construct multivalued atomic n-writer n-reader registers. The first solution uses atomic 1-write 1-reader registers and unbounded tags. The other solution uses atomic 1-write n-reader registers and bounded tags. The second part of the paper develops a general methodology to porve atomicity, by identifying a set of criteria which guaranty an effective construction for the required atomic mapping. We apply the method to prove atomicity of the two implementations for atomic multiwriter multireader registers.

Theory of Computation Group Research Summary June 1985 - July 1986

2023-03-30T04:19:31Z

Theory of Computation Group Research Summary June 1985 - July 1986 Theory of Computation Group

Hierarchical Inequality Reasoning

2023-03-30T04:08:41Z

Hierarchical Inequality Reasoning Sacks, Elisha P. This paper describes a program called BOUNDER that proves inequalities between elementary functions over finite sets of constraints. Previous inequality algorithms perform well on some subset of the elementary functions, but poorly elsewhere. Although complex algorithms perform better than simple ones for most functions, exceptions exist. To overcome these problems, BOUNDER maintains a hierarchy of increasingly complex algorithms. When on fails to resolve an inequality, it tries the next. This strategy resolves more inequalities than any single algorithm. It also performs well on hard problems without wasting time on easier ones. The current hierarchy consists of four algorithms: bounds propogation, substitution, derivative inspection, and iterative approximation. Propogation is an extension of interval arithmetic that takes linear time, but ignores constraints between variables and multiple occurences of variables. The remaining algorithms consider these factors, but require exponential time. Substitution is a new, provably correct, algorithm for utilizing constraints between variables. An earlier attempt by Brooks does not terminate on all inputs and exploits fewer constraints. The final two algorithms analyze constraints between variables. Inspection examines the signs of partial derivatives. Iteration is based on several earlier algorithms from interval arithmetic.

Game Tree Searching by Min/Max Approximation

2023-03-30T03:42:48Z

Game Tree Searching by Min/Max Approximation Rivest, Ronald L.

An Artificial Intelligence Approach to Clinical Decision Making

2023-03-30T03:40:39Z

An Artificial Intelligence Approach to Clinical Decision Making Szolovits, Peter; Kassirer, Jerome P.; Long, William J.; Moskowitz, Alan J.; Pauker, Stephen G.; Patil, Ramesh S.; Wellman, Michael P. This memo is the text of a proposal from the MIT Laboratory for Computer Science Clinical Decision Making group to the National Library of Medicine, requesting support for a five-year program of research.

Retiming Synchronous Circuitry

2023-03-30T03:02:50Z

Retiming Synchronous Circuitry Leiserson, Charles E.; Saxe, James B. This paper shows how the technique of retiming can be used to transform a given sycnhronous circuit into a more efficient circuit under a variety of different cost criteria. We model a circuit as a graph, and we give an O(|V||E|log|V|) algorithm for determining an equivalent circuit with the smallest possible clock period. We show that the problem of determining an equivalent retimed circuit with minimum state (total number of registers) is polynomial-time solvable. This result yields a polynomimal-time optimal solution to the problem of pipelining combinatorial circuitry with minimum register cost. We also give a characterization of optimal retiming based on an efficiently solvable mixed-integer linear programming problem.

Floyd-Hoare Logic Defines Semantics

2023-03-30T04:10:35Z

Floyd-Hoare Logic Defines Semantics Meyer, Albert R. The first-order patrial correctness assertions provable in Floyd-Hoare logic about an uninterpreted while-program scheme determine the scheme up to equivalence. This settles an open problem of Meyer and Halpern. The simple proof of this fact carries over to other partial correctness axiomatizations given in the literature for wider classes of ALGOL-like program schemes.

Randomized Routing on Fat-trees

2023-03-30T04:20:04Z

Randomized Routing on Fat-trees Greenberg, Ronald I.; Leiserson, Charles E. Fat-trees are a class of routing networks for hardware-efficient paralle computation. This paper presents a randomized algorithm for routing messages on a fat-tree. The quality of the algorithm is measured in terms of the load factor of a set of messages to be routed, which is a lower bound on the time required to deliver the messages. We show that if a set of messages has load factor lambda on a fat-tree with n processors, the number of delivery cyles (routing attempts) that the algorithm requires is O(lambda + lg n lg lg n) with probability 1-O(1/n). The best previous bound was )(lambda lg n) for the off-line problem where switch settings can be determined in advance. In a VLSI-like model where hardware cost is equated with physical volume, the routing algorithm demonstrates that fat-trees are universal routing networks in the sense that any routing network can be efficiently simulated by a fat-tree of comparable hardward cost.

Nonsequential Computation and Laws of Nature

2023-03-30T03:39:46Z

Nonsequential Computation and Laws of Nature Vitányi, Paul M.B. Traditionally, computational complexity theory deals with sequential computations. In the computational models the underlying physics is hardly accounted for. This attitude has persisted in common models for parallel computations. Wrongly, we shall argue, since the laws of physic intrude forcefully when we want to obtain realistic estimates of the performance of paralle or distributed algorithms. First, we shall explain why it is reasonable to abstract away from the physical details in sequential computations. Second, we show why certain common approaches in the theory of paralle complexity do not give useful information about the actual complexity of the parallel computation. Third, we give some examples of the interplay between physical considerations and actual complexity of distributed computations.

Representing Change

2023-03-30T03:51:53Z

Representing Change Sacks, Elisha This paper evaluates knowledge representations for time-dependent information. It compares recent work by Moore, McDermott, and Allen with an ealier proposal by McCarthy and Hayes. Moore's formalism is faulted for its needless and unmotivated complexity and a simpler alternative is outlined. McDermott's formalism is proved inconsistent and unintuitive. Allen achieves the most by attempting the least. He proposes a simple plausible formalism, which makes few ontological or computational commitments. The paper concludes with a high-level discussion of the merits formal logic as a representation for empirical knowledge.

Distributed Control in Computer Networks and Cross-sections of Colored Multidimensional Bodies

2023-03-30T03:23:32Z

Distributed Control in Computer Networks and Cross-sections of Colored Multidimensional Bodies Kranakis, Evangelos; Vitanti, Paul M.B. The number of messages to match a pair of processes in a multiprocessor network with mobile processes is a measure for the cost of setting up temporary communication between processes. We establish lower bounds on the average number of point-to-point transmissions between any pair of nodes in this context. The present analysis allows for the possibility of multiple transmissions (as opposed to a single one) between any two nodes, and also for the possibility of multiple queries (as opposed to the two, i.e. post and a single query considered before). Applications of the results include lower bounds on the number of messages for distributed s-matching, that is, matching a group of s processes, and distributed s-mutual exclusion, that is, s-1 processes may enter a critical section simultaneously, but s process may not, for >=2. The idea of the proof of the combinatorial result needed for this analysis is further extended to obtain a lower bound on the average number of colors occuring in random cross-sections of colored, multidimensional bodies in terms of the total (multidimensional) volume of each color in the whole body.

The Power of the Queue

2023-03-30T03:44:38Z

The Power of the Queue Li, Ming; Longpre, Luc; Vitányi, Paul M.B. Queues, stacks (pushdown stores), and tapes are storage models which have direct applications in compiler design and the general desig of algorithms. Whereas stacks (pushdown store or last-in-first-out storage) have been thoroughly investigated and are well understood, this is much less the case for queues (first-in-first-out storage). This paper contains a comprehensive study comparing queues to stacks and tapes. We address off-line machines with a one-way input, both deterministic and nondeterministic. The techniques relly on algorithmic information theory (Kolmogorov Complexity).

A Survey of Algorithms for Integrating Wafer-scale Systolic Arrays

2023-03-30T03:49:24Z

A Survey of Algorithms for Integrating Wafer-scale Systolic Arrays Leighton, Tom; Leiserson, Charles VLSI technologists are fast developing wafer-scale integration. Rather than partitioning a silicon wafer into chips as is usually done, the idea behind wafer-scale integration is to assemble an entire system (or network of chips) on a single wafer, thus avoiding the costs and performance loss associated with individual packaging of chips. A major problem with assembling a large system of microprocessors on a single wafer, however, is that some of the processor, or cells, on the wafer are likely to be defective. In the paper, we describe practical procedures for integrating wafer-scale systems "around" such faults. The procedures are designed to minimize the length of the longest wire in the system, thus minimizing the communication time between cells. Although the underlying network problems are NP-complete, we prove that the procedures are reliable by assuming a probabilistic model of cell failure.

Interval and Recency-rank Source Coding: Two On-line Adaptive Variable-length Schemes

2023-03-30T03:50:13Z

Interval and Recency-rank Source Coding: Two On-line Adaptive Variable-length Schemes Elias, Peter In these schemes the encoder maps each message into a codeword in a prefix-free codeword set. In interval encoding the codeword is indexed by the interval since the last previous occurrence of that message, and the codeword set must be countably infinite. In recency rank encoding the codeword is indexed by the number of distinct messages in that interval, and there must be no fewer codewords than messages. The decoder decodes each codewords on receipt. Users need not know message probabilities but must agree on indexings, of the codeword set in an order of increasing length and of the message set in some arbitrary order. The average codeword length over a communications bout is never much larger than the value for an off-line scheme which maps the jth most frequent message in the bout into the jth shortest codeword in the give set, and is never too much larger than the value for off-line Huffman encoding of messages into the codeword set best for the bout message frequencies. Both schemes can do much better than Huffman coding when successive selections of each message type cluster much more than in the independent case.

Knowledge and Common Knowledge in a Byzantine Environment: Crash failures

2023-03-30T03:55:15Z

Knowledge and Common Knowledge in a Byzantine Environment: Crash failures Dwork, Cynthia; Moses, Yoram By analyzing the states of knowledge that the processors attain in an unreliable system of a simple type, we capture some of the basic underlying structure of such systems. In particular, we study what facts become common knowledge at various points in the execution of protocols in an unreliable system. This characterizes the simultaneous actions that can be carried out in such systems. For example, we obtain a complete characterization of the number of rounds required to reach Simultaneous Byzantine Agreement, given the pattern in which failures occur. From this we derive a new protocol for this problem that is optimal in all runs, rather than just always matching the worst-case lower bound. In some cases this protocol attains Simultaneous Byzantine Agreement in as few as 2 rounds. We also present a non-trivial simultaneous agreement problem called bivalent agreement for which there is a protocol that always halts in two rounds. Our analysis applies to simultaneous actions in general, and not just to Byzantine agreement. The lower bound proofs presented here generalize and simplify the previously known proofs.

An Application of Digital Broadcast Communication to Large Scale Information Systems

2023-03-30T03:48:44Z

An Application of Digital Broadcast Communication to Large Scale Information Systems Gifford, David K.; Lucassen, John M.; Berline, Stephen T. A new type of information system is described that combines personal computers, broadcast data communication, and bidirectional communication. The system is designed to use broadcast communciation whenever possible to deliever information to personal computers, which are used for data storage, indexing, and retrieval. This paper starts with an overview of the system, and then discuss the problem of reliable digital broadcast communication in some detail. A parameterized broadcast protocol is described, and we show how to choose protocol parameters based on observed channel error characteristics. A flexible encryption-based protection system is included in the protocol. We discuss the implementation of the system on contemporary personal computers. A broadcast system based on these ideas is now operating in Boston area homes.

Tight Bounds for Minimax Grid Matching, with Applications to the Average Case Analysis of Algorithms

2023-03-30T03:48:24Z

Tight Bounds for Minimax Grid Matching, with Applications to the Average Case Analysis of Algorithms Leighton, Tom; Shor, Peter The minimax grid matching problem is a fundamental combinatorial problem associated with the average case analysis of algorithms. The problem has arisen in a number of interesting and seemingly unrelated areas, including wafer-scale integration of systolic arrays, two-dimentsional discrepancy problems, and testing pseudorandom number generators. However, the minimax grid matching problem is best known for its application to the maximum up-right matching problem. The maximum up-right matching problem was originally defined by Karp, Luby and Marchetti-Spaccamela in association with algorithms for 2-dimensional bin packing. More recently, the up-right matching problem has arisen in the average case analysis of on-line algorithms for 1-dimensional bin packing and dynamic allocation. In this paper, we solve both the minimax grid matching problem and the maximum up-right matching problem. As a direct result, we obtain tight upper bounds on the average case behavior of the best algorithms known for 2-dimensional bin packing, 1-dimensional on-line packing and on-line dynamic allocation. The results also solve a long-open question in mathematical statistics.

A Randomized Data Structure for Ordered Sets

2023-03-30T03:17:03Z

A Randomized Data Structure for Ordered Sets Bentley, Jon L.; Leighton Frank Thomson; Lepley, Margaret; Stanat, Donald F.; Steele, J. Michael In this paper, we consider a simple randomized data structure for representing ordered sets, and give a precise combinatorial analysis of the time required to perform various operations. In addition to a practical data structure, this work provides new and nontrivial proabilistic lower bounds and an instance of a practical problem whose randomized complexity is provably less than its deterministic complexity.

Cellular Automata Supercomputers for Fluid Dynamics Modeling

2023-03-30T04:13:22Z

Cellular Automata Supercomputers for Fluid Dynamics Modeling Margolis, Norman; Toffoli, Tommaso; Vichniac, Gerard We report recent developments in the modeling of fluid dynamics, and give experimental results (including dynamical exponents) obtained using cellular automata machines. Because of their locality and uniformity, cellular automata lend themselves to an extremely efficient physical realization; with a suitable architecture, an amount of hardware resources comparable to that of a home computer can achieve (in the simulation of cellular automata) the performance of a conventional supercomputer.

Atomic Data Abstractions in a Distributed Collaborative Editing System (Extended Abstract)

2023-03-30T03:41:07Z

Atomic Data Abstractions in a Distributed Collaborative Editing System (Extended Abstract) Greif, Irene; Selinger, Robert; Weihl, William This paper describes our experience implementing CES, a distributed Collaborative Editing System written in Argus, a language that includes facilities for managing long-lived distributed data. Argus provides atomic actions, which simplify the handling of concurrency and failures, and t the mechanisms for implementing atomic data types, which ensure serializability and recoverability of actions that use them. This paper focuses on the support for atomicity in Argus, especially the support for building new atomic types. Overall the mechanisms in Argus made it relatively easy to build CES; however, we encountered interesting problems in several areas. For example, much of the processing of an atomic action in Argus is handled automatically by the run-time system; several examples are presented that illustrate areas where more explicit control in the implementations of atomic types would be useful.

Dataflow Architectures

2023-03-30T03:10:06Z

Dataflow Architectures Arvind; Culler, David E. Dataflow graphs are described as a machine language for parallel machines. Static and dynamic dataflow architectures are presented as two implementations of the abstract dataflow model. Static dataflow allows at most one token per arc in dataflow graphs and thus only approximates the abstract model where unbounded token storage per arc is assumed. Dynamic architectures tag each token and keep then in a common pool storage, thus permitting a better approximation of the abstract model. The relative merits of the two approaches are discussed. Functional data structures and I-structures are presented as two views of data structures which are both compatible with the dataflow model. These views are contrasted and compared in regard to efficiency and exploitation of potential parallelism in programs. A discussion of major dataflow projects and a prognosis for dataflow architectures are also presented.

Width-3 Permutation Branching Programs

2023-03-30T03:13:07Z

Width-3 Permutation Branching Programs Barrington, David A. We consider a restricted class of width-3 branching programs where each column of nodes depends on a single variable, and the 0-edges and the 1-edges out of each column form a permutation. In this model, parity and the mod-3 function are easy to calculate, but the and-function is hard. We show that any function of n inputs can be calculated in length O(2^n), and that the and-function in particular requires length O(2^n) if the branching program has one accept node and one reject node.

Packet Trains: Measurements and a New Model for Computer Network Traffic

2023-03-30T04:07:32Z

Packet Trains: Measurements and a New Model for Computer Network Traffic Jain, Raj; Routhier, Shawn Traffic measurements on a ring local area computer network at Massachusetts Institute of Technology are presented. The analysis of the arrival pattern shows that the arrival processes are neither Poisson nor Compound Poisson. An alternative model called "packet train" is proposed. In the train model, the traffic on the network consists of a number of packet streams between various pairs of nodes on the network. Each node-pair stream (or node-pair process, as we call them) consists of a number of trains. Each train consists of a number of packets (or cars) going in either direction (from node A to B or from node B to A). The inter-car gap is large (compared to packet transmission time) and random. The inter-train time is even larger. The Poisson and the Compound Poisson arrivals are shown to be special cases of the train arrival model. Another important observation is that the packet arrivals exhibit a "source locality." If a packet is seen on the network going from A to B, the probability of the next packet going from A to B or from B to A is very high. Implications of the train arrivals, and source locality on the design of bridges, gateways and reservation protocols are discussed. A number of open problems requiring development of analysis techniques for systems with train arrival processes are also described.

A New Max-flow Algorithm

2023-03-30T03:47:19Z

A New Max-flow Algorithm Goldberg, Andrew V. All previously known max-flow algorithms worked by finding augmenting paths, either one path at a time (Ford and Fulkerson algorithm), or all shortest augmenting paths at once (by using the level network technique of Dinic). We introduce an alternative way of dealing with the problem. Our method is to push flow through the original network. The algorithm and its analysis are simple and intuitive, yet the algorithm does as well as any other network flow algorithm on dense graphs, achieving O(n^3) running time. The algorithm admits distributed and parallel implementations as well as a sequential implementation. The algorithm requires less storage then the only other parallel max-flow algorithm known (due to Shiloach and Vishkin), and its parallel running time is the same, O(n^2 logn). In fact, our algorithm uses constant amount of storage for every edge or vertex of the network, allowing an implementation under and more realistic distributed model.

Distributed FIFO Allocation of Identical Resources Using Small Shared Space

2023-03-30T04:04:27Z

Distributed FIFO Allocation of Identical Resources Using Small Shared Space Fischer, Michael J.; Lynch, Nancy A.; Burns, James; Borodin, Allan We present a simple and efficient algorithm for the FIFO allocation of k identical resources among asynchronous processes which communicate via shared memory. The algorithm simulates a shared queue but uses exponentially fewer shared memory values, resulting in practical savings of time and space as well as program complexity. The algorithm is robust against processes failure through unannounced stopping, making it attractive also for use in an environment of processes of widely differing speeds. In addition to its practical advantages, we show the algorithm is optimal (to within a constant factor) with respect to shared space complexity.

The CAM-7 Multiprocessor: A Cellular Automata Machine

2023-03-30T03:21:50Z

The CAM-7 Multiprocessor: A Cellular Automata Machine Toffoli, Tommaso; Margolis, Norman

Dscribe: A Scribe Server

2023-03-30T03:40:28Z

Dscribe: A Scribe Server Chung, Janice C. This document gives a complete description of the design and implementation of Dscribe, the Scribe server. Dscribe is a program which allows users on a variety of hosts to have files processed remotely by the Scribe document preparation system. The first part of the document describes the functionality of Dscribe and the motivation for writing the program. It also gives an overview of how the program works. Later sections discuss important design issues and describe the implementation in detail.

Network Control by Bayesian Broadcast

2023-03-30T03:10:12Z

Network Control by Bayesian Broadcast Rivest, Ronald L.

Improvements of Yao's Results on Parity Circuits

2023-03-30T04:04:16Z

Improvements of Yao's Results on Parity Circuits Hastad, Johan

Two Undecidability Results in Probabilistic Automata Theory

2023-03-30T03:40:21Z

Two Undecidability Results in Probabilistic Automata Theory Kilian, Joseph J. The language accepted by a probabilistic finite state acceptor with an isolated cutpoint is known to be regular. We show that determining if a cutpoint is isolated is undecideable.

A Mixed Integer Linear Programming Problem Which is Efficiently Solvable

2023-03-30T03:59:27Z

A Mixed Integer Linear Programming Problem Which is Efficiently Solvable Leiserson, Charles E.; Saxe, James B. Efficient algorithms are known for the simple linear programming problem where each inequality is of the form xj-xi<=aij. Furthermore, these techniques extend to the integer linear programming variant of the problem. This paper gives an efficient solution to the mixed-integer linear programming variant where some, but not necessarily all, of the unknowns are required to be integers. The algorithm we develop is based on a graph representation of the constraint system and runs in O(|V||E|+|V|62lh|V|) time. It has several applications including optimal retiming of synchronous circuitry, VLSI layout compaction in the presence of power and ground buses, and PERT scheduling with periodic constraints.

Unbiased Bits from Sources of Weak Randomness and Probabilistic Communication Complexity

2023-03-30T03:43:33Z

Unbiased Bits from Sources of Weak Randomness and Probabilistic Communication Complexity Chor, Benny; Goldreich, Oded A new model for weak random physical sources is presented. The new model strictly generalizes previous models (e.g. the Santha and Vazirani model [26]). The sources considered output strings according to probability distributions in which no single string is too probable. The new model provides a fruitful viewpoint on problems studied previously as: 1) Extracting almost perfect bits from sources of weak randomness: the question of possibility as well as the question of efficiency of such extraction schemes are addressed. 2) Probabilistic Communication Complexity: it is shown that most functions have linear communication complexity in a very strong probabilistic sense. 3) Robustness of BPP with respect to sources of weak randomness (generalizing a result of Vazirani and Vazirani [29]).

Computer-based Real-time Conferences

2023-03-30T04:09:33Z

Computer-based Real-time Conferences Sarin, Sunil K.; Greif, Irene A real-time conferencing system allows a group of users to conduct a problem-solving meeting from their workstations. Participants in such a conference use the computer to jointly view, edit, and process relevant information, and use voice communication to discuss the information they are sharing. General principles are presented in this paper for selecting a set of user functions in a real-time conferencing system. The available implementation strategies are reviewed and compared, with emphasis on the tradeoffs between reusing existing single-user interactive programs and writing new distributed multi-user programs. Network communication requirements for real-time conferences, and their potential impact on communication protocol standards, are discussed. Real-time conferencing is contrasted with aynchronous communication support such as electronic message systems and shared databases, and the need for the two to work together within the total system environment is emphasized.

What Price for Eliminating Expression Side-effects?

2023-03-30T03:27:25Z

What Price for Eliminating Expression Side-effects? Hailperin, Max Separating a programming language into side-effect-free expressions and effect-only statements should make the language more amenable to axiomatization, as well as providing benefits for style, pedagogy, and implementation efficiency (particularly in parallel-computing environments). This paper shows that such a division does not come at an unreasonable cost in programming convenience. First a dialect of Lisp is defined, in which a distinction is made between statements, which may have side-effects, and expressions, which may not. Next, a representative collection of examples from Abelson and Sussman's Structure and Interpretation of Computer Programs is coded in this dialect of Lisp. Most of the examples divide neatly into functional and imperative portions, and a few relatively clean transformations prove sufficient for the more stubborn cases.

Qualitative Simulation in Medical Physiology: A Progress Report

2023-03-30T03:16:52Z

Qualitative Simulation in Medical Physiology: A Progress Report Kuipers, Benjamin This progress report describes the current status of the application of the QSIM qualitative simulation representation and algorithm to mechanisms drawn from medical physiology. QSIM takes a qualitative description of the structure of a mechanism and produces and qualitative description of its behavior. Here we apply it to a set of different, medically realistic examples, to represent the following kinds of knowledge: 1) Physiology: qualitative simulation handles the response of normally-functioning mechanisms for salt and water balance to a variety of different environmental perturbations. 2) Pathophysiology: local changes to the structure describing a normal mechanism produces a structure that accurately describes the pathophysiology of a set of diseases. 3) Abstraction: the knowledge of the complexity of human physiology can only be handled by organizing it hierarchically. A hierarchy according to the temporal scale of equilibrium processes appears to be promising. 4) Cardiology: a complex structure describing maintenance of heart rate and blood pressure was adequately constructed during a short meeting with a set of computationally sophisticated physicians. 5) Future Directions: we can outline some of the representation barriers in the way of capturing a broader range of medical knowledge.

Probabilistic Analysis of a Network Resource Allocation Algorithm

2023-03-30T03:34:20Z

Probabilistic Analysis of a Network Resource Allocation Algorithm Fischer, Michael J.; Griffeth, Nancy; Guibas, Leonidas J.; Lynch, Nancy A. A distributed algorithm is presented, for allocating a large number of identical resources (such as airline tickets) to requests which can arrive anywhere in a distributed network. Resources, one allocated, are never returned. The algorithm searches sequentially, exhausting certain neighborhoods of the request origin before proceeding to search at great distances. Choice of search direction is made nondeterministically. Analysis of expected response time is simplified by assuming that the search direction is chosen probabilistically, that messages require constant time, that the network is a tree with all leaves at the same distance from the root, and that requests and resources occur only at leaves. It is shown that the response time is approximated by the number of messages of one that are sent during the execution of the algorithm, and that this number of messages is a nondecreasing function of the interarrival time for requests. Therefor, the worst case occurs when requests come in so far apart that they are processed sequentially. The expected time for the sequential case of the algorithm is analyzed by standard techniques. This time is shown to be bounded by a constant, independent of the size of the network. It follows that the expected response time for the algorithm is bounded in the same way.

Electing a Leader in a Synchronous Ring

2023-03-30T04:20:54Z

Electing a Leader in a Synchronous Ring Frederickson, Greg N.; Lynch, Nancy A. We consider the problem of electing a leader in a synchronous ring of n processors. We obtain both positive and negative results. One the one hand, we show that if processor ID's are chosen from some countable set, then there is an alorithm which uses only O(n) messages in the worst case. On the other hand, we obtain two lower bound results. If the algorithm is restructed to use only comparisons of ID's, then we obtain an Ω(n log n) lower bound for the number of messages required in the worst case. Alternatively, there is a (very fast-growing) function f with the following property. If the number of rounds is required to be bounded by some t in the worst case, and ID's are chosen from any set having at leas f(n,t) elements, then any algorithm requires Ω(n log n) messages in the worst case.

Reaching Approximate Agreement in the Presence of Faults

2023-03-30T04:13:08Z

Reaching Approximate Agreement in the Presence of Faults Dolev, Danny; Lynch, Nancy A.; Pinter, Shlomit S.; Stark, Eugene W.; Weihl, William E. This paper considers a variant of the Byzantine Generals problem, in which processes start with arbitrary real values rather than Booleann values or values from some bounded range, and in which approximate, rather than exact, agreement is the desired goal. Algorithms are presented to reach approximate agreement in aynchronous, as well as synchornous systems. The asynchronous agreement algorithm is an interesting contrast to a result of Fischer, Lynch, and Paterson, who show that exact agreement is not attainable in an asychronous system with as few as one fault process. The algorithms work by successive approximation, with a provable convergence rate that depends on the ratio between the number of faulty processes and the total number of processes. Lower bounds on the convergence rate for algorithms of this form are proven, and the algorithms presented are shown to be optimal.

The Byzantine Firing Squad Problem

2023-03-30T04:10:23Z

The Byzantine Firing Squad Problem Burns, James E.; Lynch, Nancy A. A new problem, the Byzanntine Firing Squad problem, is defined and solved in two versions, Permissive and Strict. Both problems provide for synchronization of initially unsychronized processors in a synchronous network, in the absense of a common clock and in the presence of a limited number of faulty processors. Solutions are given which take the same number of rounds as Byzantine Agreement but might transmit r times as many bits, where r is the number of rounds used. Additional solutions are provided which use at most one (Permissive) or two (Strict) additional rounds and send at most n^2 bits plus four times the number of bits sent by a chosen Byzantine Agreement algorithm.

Qualitative Simulation of Mechanisms

2023-03-30T03:01:07Z

Qualitative Simulation of Mechanisms Kuipers, Benjamin Qualitative simulation is a key inference process in qualitative causal reasoning. However, the precise meaning of the different proposals and their relation with differential equations is often unclear. In this paper, we present a precise definition of qualitative structure and behavior descriptions as abstractions of differential equations and continuously differentiable functions. We present a new algorithm for qualitative simulation that generalizes the best features of existing algorithms, and allows direct comparisons among alternate approaches. Starting with a structural description abstracted from a differential equation, we prove that the QSIM algorithm is guaranteed to produce a qualitative behavior corresponding to any solution to the original equation. We also show that any qualitative simulation algorithm, because of its local point of view, will sometimes produce spurious qualitative behaviors: ones which do not correspond to any mechanism satisfying the structureal description. These observations suggest specific types of care that must be taken in designing applications of qualitative causal reasoning systems, and in constructing and validating a knowledge base of mechanism descriptions.

Generalized Planar Matching

2023-03-30T03:12:26Z

Generalized Planar Matching Berman, Fran; Leighton, Tom; Shor, Peter; Snyder, Larry In this paper, we prove that maximum planar H-matching (the problem of determining the maximum number of node-disjointed copies of the fixed graph H contained in a variable planar graph G) is NP-complete for any connected planar graph H with three or more nodes. We also show that perfect planar H-matching is NP-complete for any connected outerplanar graph H with three or more nodes, and is, somewhat surprisingly, solvable in linear time for triangulated H with four or more nodes. The results generalize and unify several special-case results proved in the literature. The techniques can also be applied to solve a variety of problems, including the optimal tile salvage problem from wafer-scale integration. Although we prove that the optimal tile salvage problem and other like it are NP-complete, we also describe provably good approximation algorithms that are suitable for practical applications.

Tight Bounds on the Complexity of Parallel Sorting

2023-03-30T04:09:20Z

Tight Bounds on the Complexity of Parallel Sorting Leighton, Tom

Patterns in Trees

2023-03-30T04:02:58Z

Patterns in Trees Dershowitz, Nachum; Zaks, Shmuel A very general enumeration formula for occurences of a pattern, or set of patterns, in the class of ordered trees with a given number of edges is presented, and its wide usefulness is demonstrated.

Consensus in the Presence of Partial Synchrony

2023-03-30T04:21:01Z

Consensus in the Presence of Partial Synchrony Dwork, Cynthia; Lynch, Nancy A.; Stockmeyer, Larry The concept of partial synchrony in a distributed system is introduced. Partial synchrony lies between the cases of a synchronous system and an asynchronous system. In a synchronous system, there is a known fixed upper bound Δ on the time required for a message to be sent from one processor to another and a known fixed upper bound Φ on the relative speeds of different processors. In an asynchronous system, no fixed uppper bounds Δ and Φ exist. In one version of partial synchrony, fixed bounds Δ and Φ exist but they are not know a priori. The problem is to design protocols which work correctly in the partially synchronous system regardless of the actual values of the bounds Δ and Φ. In another version of partial synchrony, the bounds are known but they are only guaranteed to hold starting at some unknown time T, and protocols must be designed to work correctly regardless of when the time T occurs. Fault tolerant consensus protocols are given for various cases of parial synchrony and various fault models. Lower bounds are also given which show in many cases that out protocols are optimal with respect to the number of faults tolerated. Our consensus protocols for partially synchronous processors use new protocols for fault-tolerant "distributed clocks" which allow partially synchronous processors to reach some approximately common notion of time.

The Colored Ticket Algorithm

2023-03-30T04:24:05Z

The Colored Ticket Algorithm Fischer, Michael J.; Lynch, Nancy A.; Burns, James; Borodin, Allan Upper and lower bounds are proved for shared space requirements for solution of a problem involving resource allocation among asynchronous processes. The problem is to allocate some number, k≥1, of resources, in an environment in which processes can fail by stopping without warning. Allocation is to be as FIFO as possible, subject to variations imposed by the possibility of failures.

Complexity of Network Synchronization

2023-03-30T03:44:48Z

Complexity of Network Synchronization Awerbuch, Baruch In this paper we investigate the problem of simulation of the synchronous network by the asynchronous one. We propose a new simulation technique, referred to as "Synchronizer" which is a new, simple methodology for desiging efficient distributed algorithms in asynchronous networks. Our Synchronizer exhibits a trade-off between its communication and time complexities, which is proved to be within a constant factor of the lower bound.

Proposal for a Small Scheme Implementation

2023-03-30T04:09:14Z

Proposal for a Small Scheme Implementation Schooler, Richard; Stamos, James W. Scheme is a lexically scoped dialect of LISP developed at MIT. In this report we determine the feasibility of implementing a Scheme-based programming/application environment on a contemporary personal computer such as the Apple Macintosh. The absense of virtual memmory, coupled with a limitation on the maximum amount of physical memory, means that space is at a premium. We suggest the use of bytecodes and sketch a possible instruction set. Because of space constraints, tail-recursion optimization and an efficient mechanism for the reclamation of inaccessible contexts are also examined. Using the built-in operating system and user interface of the Macintosh realizes speed, functionality, and friendliness but raises a number of interesting issues. For example, the Pascal and assembler routines make many assumptions about data representation, type checking, and parameter passing. Since an implementation of Scheme is likely to have radically different conventions, the two environments must be interfaced smoothly and efficiently. In addition to the bytecode instruction set, we specify the virtual machine informally, discuss the implementation of basic and advanced features, and estimate the performance of such an implementation, and finally evaluate the proposed design.

A Simple and Efficient Randomized Byzantine Agreement Algorithm

2023-03-30T04:22:05Z

A Simple and Efficient Randomized Byzantine Agreement Algorithm Chor, Benny; Coan, Brian A. A new randomized Byantine agreement algorithm is presented. This algorithm operates in a synchronous systems of n processors, at most t of which can fail. The algorithm reaches agreement in O(t/log n) expected rounds and O(n^2 t/log n) expected message bits independent of the distribution of processor failures. This performance is further improved to a constant expected number of rounds and O(n^2) message bits if the distribution of processor failures is assumed to be uniform. In either event, the algorithm improves on the known lower bound on rounds for deterministic algorithms. Some other advantages of the algorithm are that it requires no cryptographic techniques, that the amount of local computation is small, and that the expected number of random bits used per processor is only one. It is argued that in many practical applications of Byzantine agreement, the randomized algorithm of this paper achieves superior performance.

A New Fault-tolerant Algorithm for Clock Sychronization

2023-03-30T03:06:43Z

A New Fault-tolerant Algorithm for Clock Sychronization Lundelius, Jennifer; Lynch, Nancy A. We describe a new fault-tolerant algorithm for solving a variant of Lamport's clock synchronization problem. The algorithm is designed for a system of distributed processes that communicate by sending messages. Each process has its own read only physical clock whose drift rate from real time is very small. By adding a value to its physical clock time, the process obtains its local time. The algorithm solves the problem of maintaining closely synchornized local times, assuming that processes' local times are closely synchronized initially. The algorithm is able to tolerate the failure of just under a third of the participating processes. It maintains synchornization to within a small constant, whose magnitude depends upon the rate of clock drift, the message delivery time, and the initial closeness of synchronization. We also give a characterization of how far the clocks drift from real time. Reintegration of a repaired process can be accomlished using a slight modification of the basic algorithm. A similiar style algorithm can also be used to achieve synchronization initially.

Software for Interactive On-line Conferences

2023-03-30T04:10:53Z

Software for Interactive On-line Conferences Sarin, Sunil K.; Greif, Irene A layered architecture for the implementation of real-time conferences is presented. In a real-time conference a group of users, each at his or her own workstation, share identical views of on-line application information. The users cooperate in a problem solving task by interactively modifying or editing the shared view or the underlying information, and can use a voice communication channel for discussion and negotiation. The lower layer in this architecture, named Ensemble, supports the sharing of arbitrary application-defined objects among the participants of a conference, and the manipulation of these objects via one or more application-defined groups of commands called activities. Ensemble provides generic facilities for sharing objects and activities, and for dynamically adding and removing participants in a conference; these can be used in constructing real-time conferencing systems for many different applications. An example is presented of how the Ensemble functions can be used to implement a shared bitmap with independent participant cursors. The relation between this layered architecture and the ISO Open Systems Interconnection reference model is discussed. In particular, it is argued that Ensemble represents a plausible first step toward a Session-layer protocol for "multi-endpoint connections," a neglected area of communication protocol development.

Naming and Directory Issues in Message Transfer Systems

2023-03-30T04:17:18Z

Naming and Directory Issues in Message Transfer Systems Sirbu, Marvin A., Jr.; Sutherland, Juliet B. A message transfer system requires some means for users to determine the addresses of their correspondents. A Directory Service aids users in identifying a particular correspondent and the correspondent's address. In this paper we discuss the technical, economic, organizational and political requirements which must be satisified by a directory service. We develop a language for describing alternative architectures for directory service borrowed from notions of hierarchical computer file system design. We propose a system of naming and directory services which meets the stated requirements based on names which specify a path through a sequence of directories. Finally, we compare our proposal to several alternative designs for directory service which have appeared in the literature.

Three-dimensional Circuit Layouts

2023-03-30T03:30:00Z

Three-dimensional Circuit Layouts Leighton, Tom; Rosenberg, Arnold

Optimal Distributed Algorithms for Sorting and Ranking

2023-03-30T04:12:43Z

Optimal Distributed Algorithms for Sorting and Ranking Zaks, Shmuel We study the problems of sorting and ranking n processors that have initial values - not necessarily distinct - in a distrubuted system. Sorting means that the initial values have to move around in the network and be assigned to the processors according to their distinct identities, while ranking means that the numbers 1,2,...,n have to be assigned to the processors according to their initial values; ties between initial values can be broken in any chosen way. Assuming a tree network, and assuming that a message can contain an initial value, an identity or a rank, we present an algorithm for the ranking problem that uses, in the worst case, at most 1/2n^2 + O(n) such messages. The algorithm is them extended to perform sorting, using in the worst case at most 3/4n^2 + O(n) messages. Both algorithms are using a total of O(n) space. The algorithms are extended to general networks. The expected behavior of these algorithms for three classes of trees are discussed. Assuming that the initial values, identities and ranks can only be compared within themselves, lower bounds of 1/2n^2 and 3/4n^2 messages are proved for a worst case execution of any algorithm to solve the ranking and sorting problems, correspondingly.

RSA/RABIN Least Significent Bits Are 1/2 + 1/poly(logN) Secure

2023-03-30T03:01:28Z

RSA/RABIN Least Significent Bits Are 1/2 + 1/poly(logN) Secure Chor, Benny; Goldreich, Oded

The Impact of Synchronous Communication on. The Problem of Electing a Leader in a Ring

2023-03-30T03:02:44Z

The Impact of Synchronous Communication on. The Problem of Electing a Leader in a Ring Lynch, Nancy A.; Frederickson, Greg N. We consider the problem of electing a leader in a synchronous ring of n processors. We obtain both positive and negative results. One the one hand, we show that if processor ID's are chosen from some countable set, then there is an alorithm which uses only O(n) messages in the worst case. On the other hand, we obtain two lower bound results. If the algorithm is restructed to use only comparisons of ID's, then we obtain an Ω(n log n) lower bound for the number of messages required in the worst case. Alternatively, there is a (very fast-growing) function f with the following property. If the number of rounds is required to be bounded by some t in the worst case, and ID's are chosen from any set having at leas f(n,t) elements, then any algorithm requires Ω(n log n) messages in the worst case.

The Semantics of Local Storage of What Makes The Free-list Free?

2023-03-30T03:02:16Z

The Semantics of Local Storage of What Makes The Free-list Free? Halpern, Joseph Y.; Meyer, Albert R.; Trakhtenbrot, B.A. Denotational semantics for an ALGOL-like language with finite-mode procedures, blocks with local storage, and sharing (aliasing) is given by translating programs into an appropriately typed lambda-calculus. Procedures are entirely explained at a purely functional level - independent of the interpretation of program constructs - by continuous models for lambda-calculus. However, the usual (cpo) models are not adequate to model local storage allocation for blocks because storage overflow presents an apparent discontinuity. New domains of store models are offered to solve this problem.

On the Sequential Nature of Unification

2023-03-30T03:39:34Z

On the Sequential Nature of Unification Dwork, Cynthia; Kanellakis, Paris C.; Mitchell, John C. The problem of unification of terms is log-space complete for P. In deriving this lower bound no use is made of the potentially concise representation of terms by directed acyclic graphs. In addition, the problem remains complete even if infinite substitutions are allowed. A consequence of this result is that parallelism cannot significantly improve on the best sequential solutions for unification. The "dual" problem of computing the congruence closure of an equivalence relation is also log-space complete for P. However, we show that for the problem of term matching, an important subcase of unification, there is a good parallel algorithm using O(log^2 n) time and n^O(1) processors on a PRAM. For the O(log^2 n) parallel time upper bound we assume that the terms are presented by directed acyclic graphs; if the longer string representation is used we obtain an O(log n) parallel time bound.

On the Numbers of Close-and-equal Pairs of Bits in a String (with Implications on the Security of RSA'S L.S.B.)

2023-03-30T03:56:33Z

On the Numbers of Close-and-equal Pairs of Bits in a String (with Implications on the Security of RSA'S L.S.B.) Goldreich, Oded We consider the following problem: Let s be a n-bit string with m ones and n-m zeros. Denote by CEt(s) the number of pairs, of equal bits which are within distance t apart, in the string s. What is the minimum value of Cet(*), when the minimum is taken over all n-bit strings which consists of m ones and n-m zeros? We prove a (reasonably) tight lower bound for this combinatorial problem. Implications, on the cryptographic secruity of the least significant bit of a message encrypted by the RSA scheme, follow. E.g. under the assumption that the RSA is unbreakable; there exist no probabilistic polynomial-time algorithm which guesses the least significant bit of a message (correctly) with probability at least 0.725, when given the encryption of the message using the RSA. This is the best result known concerning the security of RSA's least significant bit.

How to Assemble Tree Machines

2023-03-30T04:15:06Z

How to Assemble Tree Machines Bhatt, Sandeep Nautam; Leiserson, Charles E. Many researchers have proposed that ensembles of processing elements be organized as trees. This paper explores how large tree machines can be assembled efficiently from smaller components. A principal constraint considered is the limited number of external connections from an integrated circuit chip. We also explore the emerging capabilities of restructurable VLSI which allows a chip to be customized after fabrication. We give a linear-area chip of m processors and only four off-chip connections which can be used as the sole building block to construct an arbirtarily large complete binary tree. We also present a restructurable linear-areas layout of m processors with O(lg m) pins that can realize an arbitrary binary tree of any size. This layout is based on a solution to the graph-theoretic problem: Given a tree in which each vertex is either black or white, determine how many edges need to be cut in order to bisect the tree into equal-size components, each containing exactly half the black and half the white vertices. These ideas extend to more general graphs using separator theoerems and bifurcators.

Empirical Analysis of a Token Ring Network

2023-03-30T03:25:17Z

Empirical Analysis of a Token Ring Network Feldmeier, David C. The MIT Laboratory for Computer Science 10 Megabit token ring local area network was monitored. Over a one-week period 7 million packets and 1.3 billion bytes passes by the monitor. This thesis compares the MIT ring traffic with that observed on the Xerox Palo Alto Research Center experimental Ethernet by Shoch and Hupp.

An Application of Number Theory to the Organization of Raster Graphics Memory

2023-03-30T03:05:27Z

An Application of Number Theory to the Organization of Raster Graphics Memory Chor, Benny; Leiserson, Charles E.; Rivest, Ronald L.; Shearer, James B. A high-resolution raster-graphics display is usually combined with processing power and a memory organization that facilitates basic graphics operations. For many applications, including interactive text processing, the ability to quickly move or copy small rectangles of pixels is essential. This paper proposes a novel organization of raster-graphics memory that permits all small rectangles to be moved efficiently. The memory organization is based on a doubly periodic assignment of pixels to M memory chips according to a "Fibonacci" lattice. The memory organization guarantees that if a rectilinearly oriented rectangle contains fewer than M/√5 pixels, then all pixels will reside in different memory chips, and thus can be accesses simultaneously. We also define a continuous analogue of the problem which can be posed as, "What is the maximum density of a set of points in the plane such that no two points are contained in the interior of a rectilinearly oriented rectangle of unit area." We show the existence of such a set with density 1/√5, and prove this is optimal by giving a matching upper bound.

On BPP

2025-07-25T00:35:20Z

On BPP Zachos, Stathis K.; Heller, Hans

Reaching Approximate Agreement in the Presence of Faults

2023-03-30T04:20:18Z

On Concurrent Identification Protocols

2023-03-30T04:18:05Z

On Concurrent Identification Protocols Goldreich, Oded We consider communication networks in which it is not possible to identify the source of a message which is broadcastes through the network. A natural question is whether it is possible for two users to identify each other concurrently, through a secure two-party protocol. We show that more than the existence of a secure Public Key Cryptosystem should be assumed in order to present a secure protocol for concurrent identification. We present two concurrent identification protocols: The first one relies on the existence of a center who has distributed "identification tags" two the users; while the second protocol relies on the distribution of "experimental sequences" by instances of a pre-protocol which have taken place between every two users.

The Markov Chain Tree Theorem

2023-03-30T03:56:34Z

The Markov Chain Tree Theorem Leighton, Frank Thomson; Rivest, Ronald L. Let M be a finite first-order stationary Markov chain. We define an arborescence to be a set of edges in the directed graph for M having at most one edge out of every vertex, no cyles, and maximum cardinality. The weight of an arborescence is defined to be the product over each edge in the arborescence of the probability of the transition associated with the edge. We prove that if M starts in state i, its limiting average probability of being in state j is proportional to the sum of the weights of all arborescences having a path from i to j and no edge out of j. We present two proofs. The first is derived from simple graph theoretic identities. The second is derived from the closely-related Matrix Tree Theorem.

Estimateing a Probability using Finite Memory

2023-03-30T03:37:56Z

Estimateing a Probability using Finite Memory Leighton, Frank Thomson; Rivest, Ronald L.

Probabilistic Searching in Sorted Linked Lists

2023-03-30T04:11:35Z

Probabilistic Searching in Sorted Linked Lists Leighton, Frank Thomson; Lepley, Margaret Janko [2] and Bentley, Stanat, and Steele [1] have described probabilistic procedures for data manipulation in sorted linnked lists. Their procedures are based on an algorithm which performs a Member search operation using 2N^1/2 + O(1) expected steps where N is the number of elements in the list. In addition, Bentley, Stanat and Steele have shown that every Member search algorithm requires (2N)^1/2 + Ω(!) expected steps. In this paper, we improve the lower bound result in order to prove that the known algorithm for Member search is optimal.

From Denotational to Operational and Axiomatic Semantics for ALGOL-like Languages: An Overview

2023-03-30T03:06:36Z

From Denotational to Operational and Axiomatic Semantics for ALGOL-like Languages: An Overview Trakhtenbrot, B.A.; Halpern, Joseph Y.; Meyer, Albert R. The advantages of denotational over operational semantics are argued. A denotational semantics is provided for an ALGOL-like language with finite-model procedures, blocks with local storage, and sharing (aliasing). Procedure declarations are completely explained in the ususal framework of complete partial orders, but cpo's are inadequate for the semantics of blocks, and a new class of store models is developed. Partial correctness theory over store models is developed for commands which may contain calls to global procedures, but do not contain function procedures returning storable values.

Understanding ALGOL: A View of a Recent Convert to Denotational Semantics

2023-03-30T04:16:09Z

Understanding ALGOL: A View of a Recent Convert to Denotational Semantics Meyer, Albert R. The advantages of denotational over copy-rule semantics are argued. A denotational semantics is indicated for an ALGOL-like language with finite-mode procedures, blocks with local storage, and sharing (aliasing). Procedure declarations are completely explained in the usual framework of complete partial orders, but cpo's are inadequate for the semantics of blocks, and a new class of store models is described. The semantics justifies a proof system for partial correctness of commands containing global procedures.

How to Construct Random Functions

2023-03-30T03:36:54Z

How to Construct Random Functions Goldreich, Oded; Goldwasser, Shafi; Micali, Silvio We assume that functions that are one-way in a very weak sense exist. We prove that in probabilitic polynomial time it is possible to construct deterministic polynomial time computable functions g:{1,…,2^k} -> {1,…,2^k} that cannot be distinguished by an probabilistic polynomial time algorithm from a random function. Loosely speaking, g provides random access to a K2^k -bit long pad whose entries record the outcome of independent coin flips. This complexity theoretic result has many important applications in Cryptography, Protocols, and Hashing.

Efficient Demand-Driven Evaluation (II)

2023-03-30T03:42:24Z

Efficient Demand-Driven Evaluation (II) Pingali, Keshav; Arvind In Part I of this paper, we presented a scheme whereby a compiler could propogate demands through programs in a powerful stream language L. A data-driven evaluation of the transformed program performed exactly the same computation as a demand-driven evaluation of the original program. In this paper, we explore a different transformation which trades the complexity of demand propogation for a bounded amount of extra computation on some data lines.

Efficient Demand-Driven Evaluation (I)

2023-03-30T04:09:27Z

Efficient Demand-Driven Evaluation (I) Pingali, Keshav; Arvind We describe a program transformation technique for programs in a general stream language L whereby a data-driven evaluation of the transformed program performs exactly the same computation as a demand-driven evaluation of the original program. The transformational technique suggests a simple denotational characterization of demand-driven evaluation.

Two Fundamental Issues in Multiprocessing: The Dataflow Solution

2023-03-30T03:55:36Z

Two Fundamental Issues in Multiprocessing: The Dataflow Solution Arvind; Iannucci, Robert A. To exploit the parallelism inherent in algorithms, any multiprocessor system must address two very basic issues - long memory latencies and waits for synchronization events. It is argued on the basis of the evolution of high performance computers that the processor idle time induced by memory latency and synchronization waits cannot be reduced simultaneously in von Neumann style multiprocessors. Dataflow architectures are offered as an alternative because, given enough parallelism in the program, they can reduce both latency and sychronization costs.

A Program for Therapy of Acid-base and Electrolyte Disorders

2023-03-30T04:01:32Z

A Program for Therapy of Acid-base and Electrolyte Disorders Bromley, Hank This thesis describes work done on the therapy component of an on-going project for the diagnosis and management of acid-base and electrolyte disoders. Therapeutic interventions can be classified as symptomatic or etiologic, and as acute or chronic. We have focused on the problem of acute symptomatic therapy. Based on observation of clinical practice, we have developed a formalization of the domain-independent aspects of the task of acute symptomatic therapy, then applied the formalization to the particular field of acid-base and electrolyte disorders. A rule-based program named ABET (the Acide-Base ad Electrolye Therapy Advisor) has been designed and written to test this formalization. The thesis presents the methods used by ABET, the program's implementation, a sample session, and a discussion of limitations and possible improvements.

Evaluation of an Office Analysis Methodology

2023-03-30T03:25:14Z

Evaluation of an Office Analysis Methodology Sutherland, Juliet; Sirbu, Marvin We have developed a model of the office that describes semi-structured office work. This model underlies an office analysis methodology and an office-specification language. An evaluation of the usefulness and practicality of the model, the specification language, and the methodology has dhown that the model is clearly a useful approach to understanding offices, the specification language is interesting but not as useful in practice as we had hoped, and the methodology is useful but could be improved. We have developed a new methodology that addresses the issue of diagnosis as well as description. This new methodology is still being evaluated, but early results show that it is as useful for training new analysts as the old methodology.

An Approximation Algorithm for Manhattan Routing

2023-03-30T03:48:56Z

An Approximation Algorithm for Manhattan Routing Baker, Brenda S.; Bhatt, Sandeep N.; Leighton, Frank Thomson Density has long been known to be an important measure of difficulty for Manhattan routing. In this paper, we identify a second important measure of difficulty, which we call flux. We show that flux, like density, is a lower bound on channel width. In addition, we present a linear-time algorithm which routes any multipoint net Manhattan routing problem with density d and flux f in a channel of width 2d+O(f). (For 2-point net, the bound is d+O(f).) Thus we show that Manhattan routing is one of the NP-complete problems for which there is a provably good approximation algorithm.

Planar Embedding of Planar Graphs

2023-03-30T03:03:51Z

Planar Embedding of Planar Graphs Dolev, Danny; Leighton, Frank Thomson; Trickey, Howard Planar embedding with minimal area of graphs on an integer grid is an interesting problem in VLSI theory. Valiant [V] gave an algorithm to construct a planar embedding for trees in linear area; he also proved that there are planar graphs that require quadratic area. We fill in a spectrum between Valiant's results by showing that a N-node planar graph has a planar embedding with area O(NF), where F is a bound on the path length from any node to the exterior face. In particular, an outerplanar graph can be embedded without crossovers in linear area. This bound is tight, up to constant factors: for any N and F, there exist graphs requiring Ω(NF) area for planar embedding. Also, finding a minimal embedding area is shown to be NP-complete for forests, and hence for more general types of graphs.

Wafer-scale Integration of Systolic Arrays

2023-03-30T03:33:37Z

Wafer-scale Integration of Systolic Arrays Leighton, Frank Thomson; Leiserson, Charles E. VLSI technologists are fast developing wafer-scale integration. Rather than partitioning a silicon wafer into chips as is usually done, the idea behind wafer-scale integration is to assemble an entire system (or network of chips) on a single wafer, thus avoiding the costs and performance loss associated with individual packaging of chips. A major problem with assembling a large system of microprocessors on a single wafer, however, is that some of the processor, or cells, on the wafer are likely to be defective. In the paper, we describe practical procedures for integrating wafer-scale systems "around" such faults. The procedures are designed to minimize the length of the longest wire in the system, thus minimizing the communication time between cells. Although the underlying network problems are NP-complete, we prove that the procedures are reliable by assuming a probabilistic model of cell failure. We also discuss applications of this work to problems in VLSI layout theory, graphy theory, fault-tolerant systems and planar geometry.

The Implication Problem for Functional and Inclusion Dependencies

2023-03-30T03:59:41Z

The Implication Problem for Functional and Inclusion Dependencies Mitchell, John C. There are two implication problems for functional dependencies and inclusion dependencies: general implication and finite implication. Given a set of dependencies ∑∪{σ}, the problems are to determine whether σ holds in all databases satisfying ∑ or all finite databases satisfying ∑. Contrary to the possibility suggested in [5], there is a natural, complete axiom system for general implication. However, a simple observation shows that both implication problems are recursively unsolvable. It follows that there is no recursively enumerable set of axioms for finite implication.

Randomized Encryption Techniques

2023-03-30T03:57:45Z

Randomized Encryption Techniques Rivest, Ronald L.; Sherman, Alan T. A randomized encryption procedure enciphers a message by randomly choosing a ciphertext from a set of ciphertexts corresponding to the message under the current encryption key. At the cost of increasing the required bandwidth, such procedures may achieve greater cryptographic security than their deterministic counterparts by increasing the apparent size of the message space, eliminating the threat of chosen plaintext attacks, and improving the a priori statistics for the inputs to the encryption algorithms. In this paper we explore various ways of using randomization in encryption.

Implementing Internet Remost Logic on a Personal Computer

2023-03-30T03:33:17Z

Implementing Internet Remost Logic on a Personal Computer Konopelski, Louis J. This thesis demonstrates that a desktop personal computer can support an efficient internet remote login implementation with the same protocols used by large mainframes. It describes a project in which the Telnet remote login protocol, along with the supporting Transmission Control Protocol and Internet Protocol were implemented on an IBM Personal Computer. The utility of the implementation depended heavily on the software speed. Strategies discusses to insure quick performance included tailoring protocols to their clients needs, sharing the overhead of asynchronous actions, and sharing data. A natural order in which to process the protocol data was identified, and two control structures were presented that allowed the protocol modules to run in this order. One of the control structures used procedures and processes, while the other used procedures alone. A full scale protocol was successfully placed in the personal computer. With some foreign hosts, the implementation echoed characters in less than a quarter of a second, and processed a screenful of data in less than three seconds. The protocol software overhead was never the dominating performance bottleneck. The serial line interface limited the character echoing performance while the speed with which the processor could operate its display limited the processing speed of large amounts of data. Memory size was not a significant constraint.

PLY: A System of Plausibility Inference with a Probabilistic Basis

2023-03-30T03:27:43Z

PLY: A System of Plausibility Inference with a Probabilistic Basis Yeh, Alexander An overview is given of a system of plausibility inference that will be developed for use in planning. This system, to be called PLY, will be specifically designed to work with propositions of the form "when A is true (occurs), B is likely to be true (to occur)." Previous systems performing similiar functions have been designed as aids for such tasks as medical diagnosis (MYCIN and others) and mineral prospecting (PROSPECTOR). PLY will have a probabilistics basis. Intuitive assumptions to deal with knowledge not explicitly given to the system will be made with the aid of an information-theoretic measure on the amount of information in a probability distribution. Unlike many other systems, PLY will not use these assumptions when the given knowledge indicates they are not tenable. In addition to standard probabilities, PLY will be able to make use of knowledge (information) in the form of correlations and increased/decreased likelihoods, which most people find easier to estimate than probabilities. PLY's knowledge will be in an organized and structures form, which will help in knowledge acquisition and revisino, faciliate system explanations, and lower the storage requirements of the system.

An Asymptotically Optimal Layout for the Shuffle-exchange Graph

2023-03-30T04:22:56Z

An Asymptotically Optimal Layout for the Shuffle-exchange Graph Kleitman, Daniel; Leighton, Frank Thomson; Lepley, Margaret; Miller, Gary L. The shuffle-exchange graph is one of the best structures known for parallel computation. Among other things, a shuffle-exchange computer can be used to compute discrete Fourier transforms, multiply matrices, evaluate polynomials, perform permutations and sort lists. The algorithms needed for these operations are quite simple and many require no more than logarithmic time and constant space per processor. In this paper, we describe an O(n^2/log^2N)-area layout for the shuffle-exchange graph on a two-dimentional grid. The layout is the first which is known to achieve Thompson's asymptotic lower bound.

Embedding Cryptographic Trapdoors in Arbirtrary Knapsack Systems

2023-03-30T03:45:58Z

Embedding Cryptographic Trapdoors in Arbirtrary Knapsack Systems Shamir, Adi In this paper we show that after sufficiently many modular multiplications, any knapsack system becomes a trapdoor system that can be used in pubic-key cryptography.

The Complexity of Evaluation Relational Queries

2023-03-30T04:14:53Z

The Complexity of Evaluation Relational Queries Cosmadakis, Stavros S. We show that, given a relation R, a relational query ? Involving only projection and join, and a conjectured result r, resting with ?(R)=r is D^p complete. Bounding the size of ?(R) from below (above) is NP-hard (co-NP-hard), and bounding it both ways is D^p hard. Computing the size of ?(R) is #P-hard. We also show that, given two relations R1 and R2 and two queries ?1 and ?2 as above, testing whether ?1)R1)⊆?2(R2) and testing whether ?1(R1)=?2(R2) and both ∏p2-complete, even when R1-R2 or when ?1=?2.

Two Remarks on the Power of Counting

2023-03-30T03:45:16Z

Two Remarks on the Power of Counting Papadimitriou, Christos H.; Zachos, Stathis K. The relationship between the polynomial hierarchy and Valiant's class #P is at present unknown. We show that some low portions of the polynomial hierarchy, namely deterministic polynomial algorithms using an NP oracle at most a logarithmic number of times, can be simulated by one #P computation. We also show that the class of problems solvable by polynomial-time nondeterministic Turing machines which accept whenever there is an odd number of accepting computations is idempotent, that is closed under usage of oracles from the same class.

New Lower Bound Techniques For VLSI

2023-03-30T03:28:44Z

New Lower Bound Techniques For VLSI Leighton, Frank Thomson In this paper, we use crossing number and wire area arguments to find lower bounds on the layout area and maximum edge length of a variety of new and computationally useful networks. In particular, we describe 1) an N-node planar graph which has layout area ⊖ (NlogN) and maximum edge length ⊖(N^1/2/log^1/2N), 2) an N-node graph with an O(x^1/2)-separator which has layout area ⊖ (Nlog^2N) and maximum edge length ⊖ (N^1/2logN/loglogN), and 3) an N-node graph with an O(x^1-1/r)-separator which has maximum edge length ⊖(N1-1/4) for an r≥3.

Hoare's Logic Is Not Complete When It Could Be

2023-03-30T03:14:58Z

Hoare's Logic Is Not Complete When It Could Be Bergstra, J.; Chielinksa, A.; Tiuryn, J. It is known (cf.[2]) that is the Hoare rules are complete for a first-order structure A, then the set of partial correctness assertions true over A is recursive in the first-order theory of A. We show that the converse is not true. Namely, there is a first-order structure C such that the set of partial correctness assertions true over C is recursive in the theory of C, but the Hoare rules are not complete for C.

Foundations for Office Semantics

2023-03-30T04:27:16Z

Foundations for Office Semantics Barber, Gerald R.; Hewitt, Carl In this paper we develop the semantics of work in the office in terms of the concepts of application structure and organizational structure of the office. Application structure is concerned with the rules and constraints of the domain of the office work such as accounting, law, or social security regulations. Organizational structure is concerned with the informal and formal social relationships within the organization. Detailed knowledge of office application structures and organizational structures is necessary in order to understand how they interact and evolve. Problem solving is a pervasive activity within offices which is performed when office workers apply general knowledge about office procedures to the specific cases encountered in their daily work. We discuss how a description system (named OMEGA) can aid in the construction of interactive systems whose intent is to describe the application and organization structures. Using the knowledge embedded within itself about the office OMEGA can help support office workers in their problems solving processes.

Supporting Organizational Problem Solving with a Workstation

2023-03-30T03:22:11Z

Supporting Organizational Problem Solving with a Workstation Barber, Gerald R. This paper describes an approach to supporting work in the office. Using and extending ideas from the field of Artificial Intelligence (AI) we describe office work as a problem solving activity. A knowledge embedding language called Omega is used to embed knowledge of the organization into an office worker's workstation in order to support the office worker in his or her problem solving. A particular approach to reasoning about change and contradiction is discussed. This approach uses Omega's viewpoint mechanism. Omega's viewpoint mechanism is a general contradiction handling facility. Unlike other Knowledge Representation systems, when a contradiction is reached the reasons for the contradiction can be analyzed by the deduction mechanisms without having to resort to a backtracking mechanism. The Viewpoint mechanism is the heart of the Problem Solving Support Paradigm. This paradigm supplements the classical AI view of problem solving. Office workers are supported using the Problem Solving Support Paradigm. An example is presented where Omega's facilities are used to support an office worker's problem solving activities. The example illustrates the use of viewpoints and of Omega's capabilities to reason about it's own reasoning process.

A Principled Design for an Integrate Computational Environment

2023-03-30T03:50:46Z

A Principled Design for an Integrate Computational Environment diSessa, Andrea A. Boxer is a computer language designed to be the base of an integrated computational environment providing a broad array of functionality -- from text editing to programming -- for naïve and novice users. It stands in the line of Lisp inspired languages (Lisp, Logo, Scheme), but differs from these in achieveing much of its understandability from pervasive use of a spatial metaphor reinforced through suitable graphics. This paper describes a set of learnability and understandability issues first and then uses them to motivate design decisions made concerning Boxer and the environment in which it is embedded.

A Telex Gateway for the Internet

2023-03-30T04:07:37Z

A Telex Gateway for the Internet Meier zu Sieker, Friedrich The design of a gateway connecting one of the networks of the MIT Laboratory for Computer Science to the telex network is discussed. A description of the telex network is given. The relationship of the gateway to other resources of the network environment is considered to obtain directions for the implementation of new resources. The implementation of the gateway on the UNIX operating system outlined.

Layouts for the Suffle-Exchange Graph Based on the Complex Plane Diagram

2023-03-30T03:46:01Z

Layouts for the Suffle-Exchange Graph Based on the Complex Plane Diagram Leighton, Frank Thomson; Lepley, Margaret; Miller, Gary L. The shuffule-exchange graph is one of the best structures known for parallel computation. Among other things, a shuffle-exchange computer can be used to compute discrete. Fourier transforms, multiply matrices, evaluate polynomials, performa permutations and sort lists. The algorithms needed for these operations are extremely simple and many require no more than logarithmic time and constant space per processor. In this paper, we analyze the algebraic structure of the shuffle-exchange graph in order to find area-efficient embeddings of the graph in a two-dimensinoal grid. The results are applicable to the design of Very Large Scale Integration (VLSI) circuit layouts for a shuffle-exchange computer.

Circuit Analysis of Self-timed Elements for NMOS VLSI Systems

2023-03-30T03:12:29Z

Circuit Analysis of Self-timed Elements for NMOS VLSI Systems Chu, Tam-Anh Scalingof VLSI digital systems introduces new problems to the design of synchronous systems, due to the disproportional increase in wire delays with the decrease in transistor sizes. One the other hand, the asynchronous self-timed design approach, which has been traditionally less attractive, offer a number of advantages for VLSI. Also, this approach can be directly incorporated into a structured design methodology for Packet Communication Architectures. This paper considers a practical self-timed design methodology and studies its implementation in nMOS. The C-element and the arbiter circuit, two main circuit components of self-timed systems, are analyzed to allow the evaluation of the design approach.

Recursive Decomposition Ordering and Multiset Orderings

2023-03-30T03:46:44Z

Recursive Decomposition Ordering and Multiset Orderings Jouannaud, Jean-Pierre; Lescanne, Pierre; Reinig, Fernand The Recursive Decomposition Ordering, a simplification ordering on terms, is useful to prove termination of term rewriting systems. In this paper we give the definition of the decomposition ordering and prove that it is a well-founded simplication ordering containing Dershowitz's Recursive Path Ordering. We also show that the Recursive Decomposition Ordering has a very interesting incremental property. In the second paper, we propose two well-founded orderings on multisets that extend the Dershowitz-Manna ordering. Unlike the Dershowitz-Manna ordering, ours do not have a natural monotonicity property. This lack of monotonicity suggests using monotonicity to provide a new characterization of the Dershowitz -Manna ordering. Section 5 proposes an efficient and correct implementation of that ordering.

Cooperative Office Work, Teleconferencing and Calendar Management: A Collection of Papers

2023-03-30T04:05:46Z

Cooperative Office Work, Teleconferencing and Calendar Management: A Collection of Papers Greif, Irene This technical memo consists of a collection of papers that have been presented at conferences. They all present results of research in the "Multi-person Informational Work" project in the Office Automation Group.

A File Transfer Program for a Personal Computer

2023-03-30T03:05:56Z

A File Transfer Program for a Personal Computer Wright, Karl D. This thesis explores engineering decisions involved in implementing a network file transfer program on a personal computer in response to criteria of low cost and reasonable efficiency. The issues include choice of hardware, design of the network, choice of implementation language, choice of communication protocols, and choice of software structure. A machine level protocol is designed. A project incorporating these and other ideas is undertaken and the ideas thus evaluated. Insight is gleaned into the performance expected under varying operating system and interrupt enviroments. A notion of an "ideal" operating system interface for applications similiar to file transfer (which can exploit concurrency) is developed. Finally, possible improvements on the actual project are suggested based in part on the efficiency data obtained.

Coping with Syntactic Ambiguity or How to Put the Block in the Box on the Table

2023-03-30T03:41:23Z

Coping with Syntactic Ambiguity or How to Put the Block in the Box on the Table Church, Kenneth; Patil, Ramesh Sentences are far more ambiguous than one might have thought. There may be hundreds, perhaps thousands of syntatic parse trees for certain very natural sentences of English. This fact has been a major problem confronting natural language processing because it indicates that it may require a long time to construct a list of all the parse trees, and furthermore, it isn't clear what to do with the list once it has ben constructed. This list may be so numerous that it is probably not the most convenient representation for communication with the semantic and pragmatic processing modules. In this paper we propose some methods for dealing with syntactic ambiguity in ways that take advantage of certain regularities among the alternative parse trees. These regularities will be expressed as linear combinations of ATN networks, and also as sums and products of formal power series. We will suggest some ways that practical processor can take advantage of this modularity in order to deal more efficiently with combinatoric ambiguity. In particular, we will show how a processor can efficiently compute the ambiguity of an input sentence (or any portion thereof). Furthermore, we will show how to compile certain grammars into a form that can be processed more efficiently. In some cases, including the "every way ambiguous" grammar (e.g., conjunction, prepositional phrases, noun-noun modification), processing time will be reduced from O9n^3) to O(n). Finally, we will show how to uncompile certain highly optimized grammars into a form suitable for linguistic analysis.

Optimizing Synchronous Systems

2023-03-30T03:47:34Z

Optimizing Synchronous Systems Leiserson, Charles E.; Saxe, James B. The complexity of integrated-circuit chips produced today makes it feasible to build inexpensive, special-purpose subsystems that rapidly solve sophisticated problems on behalf of a general-purpose host computer. This paper contributes to the design methodology of efficient VLSI algorithms. We present a transformation that converts synchronous systems into more time-efficient, systolic implementations by removing combinatorial rippling. The problem of determining the optimized system can be reduced to the graph-theoretic single-destination-shortest-paths problem. More importantly from an engineering standpoint, however, the kinds of rippling that can be removed from a circuit at essentially no cost can be easily characterized. For example, if the only global communication in a system is broadcasting from the host computer, the broadcast can always be replaced by local communication.

Termination Assertions for Recursive Programs: Completeness and Axiomatic Definability

2023-03-30T03:17:23Z

Termination Assertions for Recursive Programs: Completeness and Axiomatic Definability Meyer, Albert R.; Mitchell, John C. The termination assertion pq means that whenever the formular p is true, there is an execution of the possibly nondeterministic program S which terminates in a state in qhich q is true. A recursive program S may declare and use local variables and nondeterministic recursive procedures with call-by-address and call-by--value parameters, in addition to accessing undeclared variables and global procedures. Assertions p and q about calls to global procedures are first order formulas extended to express hypotheses about the termination of calls to undeclared global procedures. A complete, effective axiom system with axioms corresponding to the syntax of the programming language is given for the termination assertinos valid over all interpretations. Termination assertions define the semantics of recursive programs in the following sense: if two programs have different input-output semantics, then there is a termination assertion that is valid for one program but not for the other. Thus the complete axiomatization of termination assertions constitutes an axiomatic definition of the semantics of recursive programs.

Minimax Optimal Universal Codeword Sets

2023-03-30T03:07:08Z
Minimax Optimal Universal Codeword Sets Elias, Peter In an interactive multi-user data-processing system a user knows the probabilities of his messages and must encode them into a fixed system-wide variable-length codeword set. He needs to receive the answer to his last message before selecting the next, so his encoding is one-shot. To minimize average codeword length he encodes his messages in order of decreasing probability into codewords in order of increasing length. I give an algorithm which, for each of several measures of performance, finds the codeword set best by that measure for the worst user, and some of the minimax optimal codeword sets the algorithm has found. Some of the results hold for all user distributions: others require e.g. that all users send exactly or at most m distinct messages, and/or that there is an integer k such that no user has a message of probability greater than 1/k.

A Note on Equivalences Among Logics of Programs

2023-03-30T03:47:58Z
A Note on Equivalences Among Logics of Programs Meyer, Albert R.; Tiuryn, Jersey Several different first order formal logics of programs -- Algoritmic Logic, Dynamic Logic, and Logic of Effective Definitions -- are compared and shown to be equivalent to a fragment of constructive L ω1ω. When programs are modelled as effective flowcharts, the logics of deterministic and nondeterministic programs are equivalent.

Software for the "Roles" People Play

2023-03-30T03:38:09Z
Software for the "Roles" People Play Greif, Irene Office work consists largely of cooperative efforts by numbers of people. To support such work, applications programs can be designed as "multi-person" systems organized around notions of "roles" and "working relationships." A group of co-workers can then describe to the system their agreed upon roles in a project as well as the working relationships among those roles. Based on this description, application software can provide support for communications protocols and access control that is tailored to the working situation. As working relationships evolve, these descriptions can be modified so that the software will continue to meet the needs of the users. The paper presents an approach to office systems research emphasizing the development of software modules that can be used to build end-user application programs. The requirements that "multi-person" applications place on this software architecture are discussed in the context of a series of examples of multi-person activities, including joint document writing and calendar management.

Computational Complexity and the Traveling Salesman Problem

2023-03-30T03:19:38Z
Computational Complexity and the Traveling Salesman Problem Johnson, David; Papadimitriou, Christos

The Traveling Saleman Problem with Many Visits to Few Cities

2023-03-30T04:18:51Z
The Traveling Saleman Problem with Many Visits to Few Cities Cosmadakis, Stavros S.; Papadimitriou, Christos H. We study the version of the traveling salesman problem in which a relatively small number of cities -- say, six -- must be visited a huge number of times -- e.g., several hundred times each. )It costs to go from one city to itself). We develop an algorithm for this problem whose running time is exponential in the number of cities, but logarithmic in the number of visits. Our algorithm is a practical approach to the problem for instances of size in the range indicated above. The implementation and analysis of our algorithm give rise to a number of interesting graph-theoretic and counting problems.

Power Set Models of Lambda-Calculus: Theories, Expansions, Isomorphisms

2023-03-30T03:37:41Z
Power Set Models of Lambda-Calculus: Theories, Expansions, Isomorphisms Longo, Guiseppe

Optimal Placement for River Routing

2023-03-30T03:34:08Z
Optimal Placement for River Routing Leiseron, Charles E.; Pinter, Ron Y. Programs for integrated circuit layout typically have two phases: placement and routing. The router should produce as efficient a layout as possible, but of course the quality of the routhing depends heavily on the quality of the placement. On the other hand, the placement procedure ideally should know the quality of a routing before it routes the wires. In this talk we present an optimal solution for a practical, common version of this placement and routing problem. River routing is the problem of connecting in order a set of terminals a1,...,an on a line to another set b1,...,bn across a rectangular channel. Since the terminals are located on modules, the modules must be placed relative to one another before routing. This placement problem arises frequently in design systems like bristle-blocks where stretch lines through a module can effectively break it into several chunks, each of which must be placed separately. In this talk, we shall present concise necessary and sufficient conditions for wirability which are applied to reduce the optimal placement problem to the graph-theoretic single-source-longest-paths problems. By exploiting the special structure of graphs that arise from the placement problem for rectilinear wiring, an optimal solution may be determined in linear time.

Circuit-size Lower Bounds and Non-reducibility to Sparse Sets

2023-03-30T03:30:57Z
Circuit-size Lower Bounds and Non-reducibility to Sparse Sets Kannan, Ravindran As remarked in Cook (1980), we do not know any nonlinear lower bound on the circuit-size of a language in P or even in NP. The best known lower bound seems to be due to Paul (1975). In this paper we show that first for each nonnegative integer k, there is a language Lk in Σ2∩π2 (of Meyer and Stockmeyer (1972) hierarchy) which does not have 0(n^k)-size circuits. Using the same techniques, one is able to prove several similar results. For example, we show that for each nonnegative integer k, there is a language Lk in NP that does not have 0(n^k)-size uniform circuits. This follows as a corollary of a stronger result shown in the paper. Finally, we note that existence of "small circuits" is in suitable contexts equivalent to being reducible to sparse sets. Using this, we are able to prove for example that for any time-constructible super-polynomial function f(n), NTIME(f(n)) contains a language which is not many-to-one p-time reducible to any sparse set.

On the Expressive Power of Dynamic Logic, II

2023-03-30T03:16:11Z
On the Expressive Power of Dynamic Logic, II Halpern, Joseph Y.

Maclisp Extensions

2023-03-30T03:32:24Z
Maclisp Extensions Bawden, Alan; Burke, Glenn S.; Hoffman, Carl W. This document describes a common subset of selected facilities available in Maclisp and its derivatives: PDP-10 and Multics Maclisp., List Machine Lisp (Zetalisp), and NIL. The object of this document is to aid people in writing code which can run compatibly in more than one of these environments.

Communication Ring Initialization Without Central Control

2023-03-30T03:33:03Z
Communication Ring Initialization Without Central Control Saltzer, Jerome H. This short memorandum describes a novel combination of three well-known techniques; the combination provides a systematic way of initializing a local-area ring network without previous, static designation of a distinguished station. The result is a distributed algorithm that dynamically designates a distinguished station from among a group of stations whose ability to communicate is hampered by the fact that the ring is not yet initialized. An appendix describes how this approach could be implemented as part of the 10 Megabit/second (version 2) ring network currently being installed at the MIT Laboratory for Computer Science.

What is a Model of the Lamda Calculus? Expanded Version

2023-03-30T03:56:21Z
What is a Model of the Lamda Calculus? Expanded Version Meyer, Albert R. An elementary, purely algebraic definition of model for the untypes lambda calculus is given. This definition is shown to be equivalent to the natural semantic definition based on environments. These definitions of model are consistent with, and yield a completeness theorem for, the standard axioms for lambda convertibility. A simple construction of models for lambda calculus is reviewed. The algebraic formulation clarifies the relation between combinators and lambda terms.

LSB Manual

2023-03-30T03:48:38Z
LSB Manual Burke, Glenn LSB (for Layered System Building) is an integrated set of facilities for aiding in the construction of highly-modular, multi-layered, implementation-independent Lisp systems. It provides for conditional inclusion of source text, documentation production, automated declarations, and "high-level" definitions. Lisp code compiled with LSB in general does not require LSB in its run-time environment. LSB has been in use for some time in PDP-10 Maclisp, is operation in Multics Maclisp and Lisp Machine Lisp, and is being developed for NIL.

The Complexity of the Word Problems for Commutative Semigroups and Polynomial Ideals

2023-03-30T03:45:31Z
The Complexity of the Word Problems for Commutative Semigroups and Polynomial Ideals Mayr, Ernst W.; Meyer, Albert R. Any decision procedure for the word problems for commutative semigroups and polynomial ideals inherently requires computational storage space growing exponentially with the size of the problem instrance to which the procedure is applied. This bound is achieved by a simple procedure for the semigroup problem.

The Propositional Dynamic Logic of Deterministic, Well-Structured Programs

2023-03-30T03:35:50Z
The Propositional Dynamic Logic of Deterministic, Well-Structured Programs Halpern, Joseph Y.; Reif, John H. We consider a restricted propositional dynamic logic, Strict Deterministic Propositional Dynamic Logic (SDPDL), which is appropriate for reasoning about deterministic well-structured programs. In contrast to PDL, for which the validity problem is known to be complete in deterministic exponential time, the validity problem for SDPDL is shown to be polynomial space complete. We also show that SDPDL is less expensive than PDL. The results rely on structure theorems for models of satifiable SDPDL formulas, and the proods give insight into the effects of nondeterminism on intractability and expressiveness in program logics.

Conservative Logic

2023-03-30T04:17:40Z
Conservative Logic Fredkin, Edward; Toffoli, Tommaso Conservative logic is a comprehensive model of computation which explicitly reflects a number of fundamental principles of physics, such as the reversibility of the dynamical laws and the conservation of certain additive quantities (amond which energy plays a distinguished role). Because it more closely mirrors physics than traditional models of computation, conservative logic is in a better position to provide indications concerning the realization of high-performance computing systems, i.e., of systems that make very efficient use of the "computing resources" actually offered by nature. In particular, conservative logic shows that it is ideally possible to build sequential circuits with zero internal power dissipation. After establishing a general framework, we discuss two specific models of computation. The first uses binary variables and is the conservative-logic counterpart of switching theory; this model proves that universal computing capabilities are compatible with the reversibility and conservation constraints. The second model, which is a refinement of the first, constitutes a substantial breakthrough in establishing a correspondence between computation and physics. In fact, this model is based on elastic collisions of identical "balls," and thus is formally identical with the atomic model that underlies the (classical) kinetic theory of perfect gases. Quite literally, the functional behavior of a general-purpose digital computer can be reproduced by a perfect gas placed in a suitably shaped container and given appropriate initial conditions.

On Concentration and Connection Networks

2023-03-30T03:54:14Z
On Concentration and Connection Networks Bhatt, Sandeep Nautam This thesis deals with the structural complexity of swicthing networks which realize concentration and connection requests when operated in a rearrangeable or incremental manner. Some of the important results and constructions are briefly reviewed. On the basis of non-constructive proof techniques used to obtain linear upper bounds on the complexity of rearrangeable concentrators, it is shown that not only are certain random graphs very likely to be rearrangeably non-blocking concentrators, but that is a randomly constructed graph is not non-blocking, then, on the average, only a constant number of edges need by added to the graph to make it non-blocking. Although the problem of recognizing non-blocking networks appears to be a computationally hard problem, the extra edges may be added to the graph efficiently, during operation of the network. Finally, we obtain a constructive as well as an improved non-constructive upper bound on the complexity of incrementally non-blocking connection networks.

Record of the Workshop on Research in Office Semantics

2023-03-30T03:46:25Z
Record of the Workshop on Research in Office Semantics Barber, Gerald R. This paper is a compendium of the ideas and issues presented at the Chatham Bars Workshop of Office Semantics. The intent of the workshop was to examine the state of the art in office systems and to elucidate the issues system designers were concerned with in developing next generation office systems. The workshop involved a cross-section of people from government, industry and academia. Presentations in the form of talks and video tapes were made of prototypical systems.

Recursion Theoretic Operators and Morphisms on Numbered Sets

2023-03-30T03:20:10Z
Recursion Theoretic Operators and Morphisms on Numbered Sets Barendregt, Henk; Longo, Giuseppe An operator is a map ?: Pω->Pω. By embedding Pω in two natural ways into the λ-calculus model Pω^2 (and T^ω) the computable maps on this latter structure induce several classes of recursion theoretic operators.

Algebraic Dependencies

2023-03-30T04:17:05Z
Algebraic Dependencies Yannakakis, Mihalis; Papadimitrou, Christos H. We propose a new kind of data dependencies called algebraic dependencies, which generalize all previous known kinds. We give a complete axiomatization of algebraic dependencies in terms of simple algebraic rewriting rules. In the process we characterize exactly the expressive power of tableaux, thus solving an open problem of Aho, Sagiv and Ullman; we show that it is NP-complete to tell whether a tableau is realizable by an expression; and we give an interesting dual interpretation of the chase procedure. We also show that algebraic dependencies over a language augmented to contain union and set difference can express arbitrary domain-independent predicates of finite index over finite relations. The class of embedded implicational dependencies recently - and independently - introduced by Fagin is shown to coincide with our algebraic dependencies. Based on this, we give a simple proof of Fagin's Armstrong relation theorem.

The Deducibility Problem in Propositional Dynamic Logic

2023-03-30T03:29:33Z
The Deducibility Problem in Propositional Dynamic Logic Meyer, Albert R.; Streett, Robert S.; Mirkowska, Grazina The problem of whether an arbitrary formula of Propositional Dynamic Logic (PDL) is deducible from a fixed axiom scheme of PDL is _ ]1-complete. Ths contrasts with the decidability of the problem when the axiom scheme is replaced by any single PDL formula.

Propositional Dynamic Logics of Programs: A Survey

2023-03-30T04:23:38Z
Propositional Dynamic Logics of Programs: A Survey Parikh, Rohit

Deterministic Propositional Dynamic Logic: Finite Models, Complexity, and Completeness

2023-03-30T03:37:28Z
Deterministic Propositional Dynamic Logic: Finite Models, Complexity, and Completeness Ben-Ari, Mordechai; Halpern, Joseph Y.; Pnueli, Amir Let p be a formular in deterministic propositional dynamic logic. A decision procedure for the satisfiability of p is given along with a construction of a finite model for every satisifiable p. The decision procedure runs in deterministic time 2^cn and the size of the model is bounded by n^2 * 4^n, where n is the lenth of p. Finally, a complete axiomatization for deterministic propositional dynamic logic is given, based on the Segerberg axioms for propositional dynamic logic.

Persistence of Vector Replacement Systems is Decidable

2023-03-30T03:10:59Z
Persistence of Vector Replacement Systems is Decidable Mayr, Ernst In a persistent vector replacement system (VRS) or Petri net, an enabled transition can become disabled only by firing itself. Here, an algorithm is presented which allows to decide whether an arbitrary VRS is persistent of not, and if so, to construct a semilinera representation of the set of states reachable in the system.

An Effective Representation of the Reachability Set of Persistent Petri Nets

2023-03-30T03:42:30Z
An Effective Representation of the Reachability Set of Persistent Petri Nets Mayr, Ernst In a persistent Petri net, an enabled transition can become disabled only by firing itself. Here, an algorithm is presented which constructs a semilinear representation of the set of states reachable in an arbitrary persistent Petri net.

Ω(n log n) Lower Bounds on Length of Boolean Formulas

2023-03-30T03:01:50Z
Ω(n log n) Lower Bounds on Length of Boolean Formulas Fischer, Michael J.; Meyer, Albert R.; Paterson, Michael S. A property of Boolean functions of n variables is described and shown to imply lower bounds as large as Ω(n log n) on the number of literals in any Boolean formula for any function with the property. Formulas over the full basis of binary operations (∧, ⊕, etc.) are considered. The lower bounds apply to all but the vanishing fraction of symmetric functions, in particular to all threshold functions with sufficiently large threshold and to the "congruent to zero modulo k" function for k>2. In the case k = 4 the bound is optimal.

BRAND X Manual

2023-03-30T04:14:47Z
BRAND X Manual Szolovits, Peter; Martin, William A. BRAND X is a simple representation language implemented as a pure extension of LISP. BRAND X provides the following additional facilities over LISP: Unique and canonical structures, property lists for all objects, labels for all objects, and a syntax to express each of these, supported by a reader and printer. BRAND X is intended as an "assembly language" for representation languages, attempting to provide facilities generally found useful in the simplest manner, without any strong commitment to specific representational conventions.

An Optimality Theory of Concurrency Control for Databases

2023-03-30T03:43:19Z
An Optimality Theory of Concurrency Control for Databases Kung, Hsing-Tsung; Papadimitrou, Christos H. A concurrency control mechanism (or a scheduler) is the component of a database system that safeguards the consistency of the database in the presence of interleaved accesses and update requests. We formally show that the performance of a scheduler, i.e. the amount of parallelism that it supports, depends explicitly upon the amount of information that is available to the scheduler. We point out that most previous work on concurrency control is simply concerned with specific points of this basic trade-off between performance and information. In fact, several of these approaches are shown to be optimal for the amount of information that they use.

Some New Methods of Music Synthesis

2023-03-30T03:43:35Z
Some New Methods of Music Synthesis Paseman, William Gerhard There are two distinct sections to this thesis. The first section discusses music composition, shows why it is a useful domain for Artificial Intelligence research and presents a set of "Design Rules" that facilitate research in the field of tonal music composition. It begins with a short chapter presenting a subset of music theory. This chapter assumes no prior knowledge of the subject, it completely defines all terms used in the thesis, and is geared particiularly toward those unfamiliar with music, those unwilling to learn standard music notation and those interested in Artificial Intelligence research. Next, (using the terms defined in the thesis), a context sensitive generative grammar for producing pitch progressions in the major mode is introduced. It is seen that the grammar can be made context free by switching between two interpretations of the input string. A mechanism for switching from one interpretation to another when parsing sentences generated from this grammar is described. It is shown that a model of music composition, perception, and improvisation fits within the framework of the grammar. This multiple view model and switching mechanism can be interpreted as a primitive "frame." The section section describes some of the problems and issues encountered while designing the initial hardware for the Music Aided Cognition Project at MIT. All of the developed hardware permits computer control, performance and recording of music in real time. The first chapter in this section discusses a machine called the Inexpensive Synthesizer/Recorder. It capable of synthesizing 14 square wave voices, each voice having a range of 7 octaves, with each octave having 12 bits of frequency control. Its purpose it to allow the user to record key depression times, key release times and key impact velocities when playing a keyboard piece. Its primary constraint was low cost, allowing many copies to be made. Its microprocessor interface allows it to be easily controlled by many different means, including home computers. The complete schematics for the synthesizer and the controller are provided as an appendix. The next chapter discusses an oscillator which synthesizes sound using 32 sine or 8 FM waveforms. The machine can be easily expanded to produce 256 sine voices and 64 (or more) FM voices. All since waveforms in both types of synthesis are weighted with two independent coefficients. Micropogrammable firmware allows one to produce sound by a limited number of methods other than sine summation or FM synthesis.

Computer Programs for Research in Gravitation and Differential Geometry

2023-03-30T03:22:59Z
Computer Programs for Research in Gravitation and Differential Geometry Pavelle, Richard; Wester, Michael This report contains a description of all current functions and features (with many examples) of the programs CTENSR and ITENSR which are available with MACSYMA. CTENSR is a standard Component TENSoR manipulation system which means that geometrical tensor objects are represented as arrays or matrices. Tensor operations such as contraction or covariant differentiation are carried out by actually summing over repeated (dummy) indices with DO statements. ITENSR, is a unique Indicial TENSoR manipulation system which is implemented by representing rensors as functions of their covariant, contravariant and derivative indicies. Tensor operations such as contraction or covariant differentiation are performed by manipulating the indices themselves rather than the components to which they correspond. The programs are connected in the sense that one can obtain an expression in ITENSR and have the corresponding expression generated in the CTENSR format automatically.

Report on the Workshop on Self-timed Systems

2023-03-30T03:35:15Z
Report on the Workshop on Self-timed Systems Bryant, Randal E.

Theory and Practice of Text Editors or A Cookbook for an Emacs

2023-03-30T03:56:19Z
Theory and Practice of Text Editors or A Cookbook for an Emacs Finseth, Craig A. A comprehensive summary of the available technology for implementing text editors. It is written to be a guide for the implementor of a text editor. It does not provide a finished, polished algorithm for any part of a text editor. Rather, it provides a breakdown of the problems involved and discusses the pitfalls and the available tradeoffs to be considered when designing a text editor. Specific reference is made to the relevant tradeoffs for an Emacs-type editor, a character-oriented, extensible display editor.

The Cryptographic Security of Compact Knapsacks (Preliminary Report)

2023-03-30T04:14:39Z
The Cryptographic Security of Compact Knapsacks (Preliminary Report) Shamir, Adi In 1978, Merkle and Hellman introduced a knapsack-based public-key cryptosystem, which received widespread attention. The two major open problems concerning this cryptosystem are: (i) Security: How difficult are the Merkle-Hellman knapsacks? (ii) Efficiency: Can the huge key size be reduced? In this paper we analyze the cryptographic security of knapsack problems with small keys, develop a new (non-enumerative) type of algorithm for solving them, and use the algorithm to show that under certain assumptions it is as difficult to find the hidden trapdoors in Merkle-Hellman knapsacks as it is to solve general knapsack problems.

Axiomatic Definitions of Programming Languages: A Theoretical Assessment

2023-03-30T03:57:16Z
Axiomatic Definitions of Programming Languages: A Theoretical Assessment Meyer, Albert R.; Halpern, Joseph Y. A precise definition is given of how partial correctness or termination assertions serve to define the semantics of classees of program schemes. Assertions involving only formulas of first order predicate calculus are proved capable of defining program scheme semantics, and effective axiom systems for deriving such assertions are described. Such axiomatic definitions are possible despite the limited expressive power of predicate calculus.

A Manager for Named, Permanent Objects

2023-03-30T03:05:17Z
A Manager for Named, Permanent Objects Marcus, Alan Michael Storing data in a computing system for a long time has been of interest ever since it was possible to do so. Classically, on stores bit- or byte- strings, or perhaps arrays of "records." Yet, current programming philosophy stresses data abstraction techniques and concepts. This report describes an object-oriented filing system which stores abstract objects, and allows the user to view the system as though one were storing abstract objects, rather than storing some external representation of the abstractions. Names may be attached to the (permanent) objects, and objects may be contained in (and may contain) other objects. Furthermore, an object may be contained in more than one object, thereby allowing the naming structure to be a network.

Critical Path Scheduling of Task Systems with Resource and Processor Constraints

2023-03-30T04:00:42Z
Critical Path Scheduling of Task Systems with Resource and Processor Constraints Lloyd, Error Lynn Several papers over the past few years have investigated minimum execution time scheduling of unit execution time (UET) task systems with resources. Because such scheduling problems are, in general, NP-hard, a variety of heuristic methods for producing schedules have been studied, among them, critical path scheduling. The strongest results to date have been for systems where there is no processor constraint. These results may be utilized for systems with a processor constraint by treating the processors as an additional resource. Unfortunately, in those cases where the number of processors is close to the number of resources, this results in an upper bound which is somewhat misleading. In this paper we investigate the performance of critical path scheduling for UET task systems with resources and a fixed number of processors. An upper bound for the worst case performance of critical path scheduling is given. This bound depends both on the number of processors and on the number of different resources. Moreover, we show that this is the best possible (asymptotic) upper bound).

On the Computational Complexity of Cardinality Constraints in Relational Databases

2023-03-30T04:12:03Z
On the Computational Complexity of Cardinality Constraints in Relational Databases Kanellakis, Paris C. We show that the problem of determining whether of not a lossless join property holds for a database, in the presence of key dependencies and cardinality constraints on the domains of the attributes is NP-complete.

Dynamic Algebras and the Nature of Induction

2023-03-30T03:40:08Z
Dynamic Algebras and the Nature of Induction Pratt, Vaughan R. Dynamic algebras constitute the variety (equationally defined class) of models of the Segerberg axioms for propositional dynamic logic. We obtrain the following results (to within inseparability). (i) In any dynamic algebra * is reflexive transitive closure. (ii) Every free dynamic algebra can be factored into finite dynamic algebras. (iii) Every finite dynamic algebra is isomorphic to a Kripke structure. (ii) and (iii) imply Parikh's completeness theorem for the Segerberg axioms. We also present an approach to treating the inductive aspect of recursion within dynamic algebras.

Semaphore Primitives and Starvation-free Mutual Exclusion

2023-03-30T04:20:50Z
Semaphore Primitives and Starvation-free Mutual Exclusion Stark, Eugene William Most discussions of semaphore primitives in the literature provide only an informal description of their behavior, rather than a more precissde definition. These informal descriptions may be incorrect, incomplete, or subject to misinterpretation. As a result, the literature actually contains several different definitions of the semaphore primitives. The differences are important, since the particular choice of definition can affect whether a solution to the mutal exclusion problem using semaphore primitives allows the possibility of process starvation. This thesis attempts to alleviate some of the confusion by giving precise definitions of two varieties of semaphore primitives; here called weak and blocked-set primitives. It is then shown that under certain natural conditions, although it is possible to implement starvation-free mutual exclusion with blocked-set semaphores, it is not possible to do so with weak semaphores. Thus weak semaphores are strictly less "powerful" than block-set semaphores.

On the Expressive Power of Dynamic Logic

2023-03-30T03:50:32Z
On the Expressive Power of Dynamic Logic Meyer, Albert R.; Winklmann, Karl We show that "looping" of while-programs can be expressed in Regular First Order Dynamic Logic, disproving a conjecture made by Harel and Pratt. In addition we show that the expressive power of quantifier-free Dynamic Logic increases when nondeterminism is introduced in the programs that are part of formulae of Dynamic Logic. Allowing Assignments of random values to variables also increases expressive power.

Definability in Dynamic Logic

2023-03-30T03:02:09Z
Definability in Dynamic Logic Meyer, Albert R.; Parikh, Rohit We study the expressive power of various versions of Dynamic Logic and compare them with each other as well as with standard languages in the logical literature. One version of Dynamic Logic is equivalent to the infinitary logic L CK ω1,ω, but regular Dynamic Logic is strictly less expressive. In particular, the ordinals ω^ω and ω^ω*2 are indistinguishable by formulas of regular Dynamic Logic.

Covering Graphs by Simple Circuits

2023-03-30T03:59:42Z
Covering Graphs by Simple Circuits Atai, Alon; Lipton, Richard J.; Papadimitriou, Christos H.; Rodeh, M.

On Linear Characterizations of Combinatorial Optimization Problems

2023-03-30T03:44:50Z
On Linear Characterizations of Combinatorial Optimization Problems Karp, Richard M. Papadimitriou, Christos H. We show that there can be no computationally tractable description by linear inequalities of the polyhedron associated with any NP-complete combinatorial optimization problem unless NP=co-NP -- a very unlikely event. We also use the recent result by Khacian to present even stronger evidence that NP-complete combinatorial optimization problems cannot have efficient generators of violated inequalities.

Worst-case and Probabilistic Analysis of a Geometric Location Problem

2023-03-30T03:57:57Z
Worst-case and Probabilistic Analysis of a Geometric Location Problem Papadimitriou, Christos H. We consider the problem of choosing K "medians" among n points on the Euclidean plane such that the sum of the distances from each of the n points to its closest median is minimized. We show that this problem is NP-complete. We also present two heuristics that produce arbitrarily good solutions with probability going to 1. One is a partition heuristic, and works when K grows lineraly -- or almost so -- with n. The other is the "honeycomb" heuristic, and is applicable to rates of grother of K of the form K ~ n^Є, 0<Є<1.

On the Complexity of Integer Programming

2023-03-30T03:37:07Z
On the Complexity of Integer Programming Papadimitriou, Christos H. We give a simple proof that integer programming is in NP. Our proof also establishes that there is a pseudopolynomial time algorithm for integer programming with any (fixed) number of constraints.

Reversible Computing

2023-03-30T04:24:41Z
Reversible Computing Toffoli, Tommaso The theory of reversible computing is based on invertible primitives and composition rules that preserve invertibility. With these constraints, one can still satisfactorily deal with both functional and structural aspects of computing processes; at the same time, one attains a closer correspondence between the behavior of abstract computing systems and the microscopic physical laws (which are presumed to be strictly reversible) that underly any concrete implementation of such systems. Here, we integrate into a comprehensive picture a variety of concepts and results. According to a physical interpretation, the central result of this paper is that it is ideally possible to build sequential circuits with zero internal power dissipation. Even when these circuits are interfaced with conventional ones, power dissipation at the interface would be at most proportional to the number of input/output lines, rather than to the number of logic gates as in conventional computers.

Ten Thousand and One Logics of Programming

2023-03-30T03:57:20Z
Ten Thousand and One Logics of Programming Meyer, Albert R.

An Efficient Algorithm for Determine the Length of the Longest Dead Path in an "LIFO" Branch-and-bound Exploration Schema

2023-03-30T03:38:06Z
An Efficient Algorithm for Determine the Length of the Longest Dead Path in an "LIFO" Branch-and-bound Exploration Schema Pallottino, Stefano; Toffoli, Tommaso The length of the longest dead path (LLDP) is a widely used parameter in estimating the efficiency of branch-and-bound optimization algorithms that employ the LIFO exploration schema. Thanks to two original theorems, we are able to present a particularly attractive procedure for determining of the LLDP. In fact, this procedure requires a number of storage variables which is independent of problem size and very small; moreover, the procedure is self-contained in the sense that it can be externally attached to any LIFO branch-and-bound program without interfering with its algorithms and data structures.

Space-Bounded Simulation of Multitape Turing Machines

2023-03-30T04:20:26Z
Space-Bounded Simulation of Multitape Turing Machines Adleman, Leonard M.; Loui, Michael C. A new proof of a theorem of Hopcroft, Paul, and Valiant is presented: every deterministic multitape Turing machine of time complexity T(n) can be simulated by a deterministic Turing machine of space complexity T(n)/log T(n). The proof includes an overlap argument.

A T=0(2^n/2), S=0(2^n/4) Algorithm for Certain NP-Complete Problems

2023-03-30T03:59:44Z
A T=0(2^n/2), S=0(2^n/4) Algorithm for Certain NP-Complete Problems Schroeppel, Richard; Shamir, Adi In this paper we develop a general prupose algorithm that can solve a number of NP-complete problems in time T=0(2^n/2) and space S=0(2^n/4). The algorithm can be generalized to a family of algorithms whose time and space complexities are related by T*S^2=0(2^n). The problems it can handle are characterized by a few decomposition axioms, and they include knapsack problems, exact satisfiability problems, set covering problems, etc. The new algorithm has a considerable cryptanalytic significance, since it can break knapsack-based cryptosystems with up to n=100 generators.

A Machine Language Instruction Set for a Data Flow Processor

2023-03-30T04:26:34Z
A Machine Language Instruction Set for a Data Flow Processor Aoki, Donald J. A data flow processor is a computer in which instructions are data driven and enabled for execution by the arrival of their operands. Data flow processors execute data flow programs, normally represented as program graphs, which represent the data dependencies between operations. This thesis presents a machine language instruction set for a Form 1 data flow machine based on the Dennis-Misunas design.

A Space Bound for One-tape Multidimensional Turing Machines

2023-03-30T03:38:45Z
A Space Bound for One-tape Multidimensional Turing Machines Loui, Michael C. Let L be a language recognized by a nondeterministic Turing machine with one d-dimensional worktape of time complexity T(n). Then L can be recognized by a deterministic Turing machine of space complexity (T(n)logT(n))^d/d+1. The prood employs a generalized crossing sequence argument.

Concurrent and Reliable Updates of Distributed Databases

2023-03-30T03:23:59Z
Concurrent and Reliable Updates of Distributed Databases Takagi, Akihiro A concurrent execution of transactions and various failures occuring during transaction processing in a distributed database system can lead to an inconsistent database state. In order to prevent such inconsistency from occuring , 1) the schedule of transactions must be equivalent to some serial schedule and 2) each transaction must be either completed or backed out. This paper develops a set of schemes that satisfy these requirements and still realize highly concurrent execution of transactions. This paper also shows how to incorporate these schemes into a multi-level distributed database system where there exists a hierarchy of transactions. Detailed algorithms for concurrent and reliable updates of distrubuted databases based on the proposed schemes are included in the appendix.

An Intermediate Form for Data Flow Programs

2023-03-30T03:24:46Z
An Intermediate Form for Data Flow Programs Leth, James William A data flow program, often represented as a data flow graph, is a program that expresses a computation by indicating the data dependencies among operators. A data flow computer is a machine designed to take advantage of concurrency in data flow graphs by executing data-independent operations in parallel (that is, a sequential ordering existing only between operations for which the result of one operation is an operand of the other). This thesis presents a form of computer representation of data flow programs (based on data flow graphs) that can serve as an intermediate form in the translation of source language code into machine code for a data flow computer. The proposed intermediate representation is implemented in the structured programming language CLU, and is designed to allow analysis and transformation of programs (for optimization purposes) to be performd either automatically or with programmer interaction.

On Data Bases with Incomplete Information

2023-03-30T03:30:15Z
On Data Bases with Incomplete Information Lipski, Witold, Jr. Semantic and logical problems arising in an incomplete information data base are investigated. A simple query language is described and its semantics is defined, which refers the queries to the information about reality contained in a data base, rather than to reality itself. This approach, called the internal interpretation, is shown to lead in a natural way to the notions of a topological Booleans algebra and a model logic related to S4, in teh same way as referring queries directly to reality (external interpretation) leads to Boolean algebras and classical logic. An axiom system is given for equivalent (with respect to the internal interpretation) transformation of queries, which is then exploited as a basic tool in a method for computing the internal intepretation for a broad class of queries. An interesting special case of the problem of determining the internal intepretation amounts to deciding whether an assertion about reality (a "yes-no" query) is consistent with the incomplete information about reality contained in a data base. We give a solution to this problem, which relies on the classical combinatorial problem of distinct representatives of subsets.

On Database Management System Architecture

2023-03-30T03:42:00Z
On Database Management System Architecture Hammer, Michael; McLeod, Dennis Despite the many advances that have been made in the field of database management in the last two decades, in many respects the paradigm of database management has not changed much since its inception. Several long-standing assumptions pervade the field and exert a great influence on the architecture of database management systems, their functions, and. the kinds of databases that they manage. This paper reconsiders some of these assumptions and suggests certain alternatives to them. In particular, it is argued that the concept of an integrated database ought to be supplanted by that of a federated database, a loose assembly of semi-independent components; the position of the database management system in the context of a total information system is reexamined, and arguments are made for extending its functional capabilities; and controlled logical redundancy in the schema is introduced as a means of improving the usability of a database and of enhancing its life-cycle performance. An underlying theme throughout is that of the importance of a semantic schema of the database, which specifies enough of the meaning of the application domain to enable enhanced functionality to be achieved. A number of characteristics of a conceptual data model (in which this scheme would be expressed) are described.

Artificial Intelligence and Clinical Problem Solving

2023-03-30T03:09:21Z
Artificial Intelligence and Clinical Problem Solving Szolovits, Peter An ambitious, but intriguing, possibility for radically increasing the availability and adequacy of health case, while containing cost, is to use the computer as a consultant to augment and extend the skills of all health care providers. We propose to pursue a program of fundamental research in representation of knowledge, decision-making, problem-solving, program explanation and clinical cognition, to understand how to construct computer programs that, as an integral part of the health care system, can amplify the knowledge and reasoning powers of medical decision makers. We plan to apply the techniques so developed to problems in the diagnosis and therapy of acid/base and electrolyte disturbances, diagnosis of birth defects using an existing date-base of diseases and associated manifestations, the development of multi-modal cancer therapy protocols, and the application of the methods of decision analysis to produce general tools for physicians to use in analysing difficult clinical cases.

Roles, Co-descriptors, and the Formal Representation of Quantified English Expressions

2023-03-30T04:19:28Z
Roles, Co-descriptors, and the Formal Representation of Quantified English Expressions Martin, William A.

Dynamic Algebras: Examples, Constructions, Application

2023-03-30T03:21:41Z
Dynamic Algebras: Examples, Constructions, Application Pratt, Vaughan R. Dynamic algebras combine the classes of Boolean (B V ' 0) and regular (R U ; *) algebras into a single finitely axiomatized variety (B R ♦) resembling an R-module with "scalar" multiplication ♦. The basis result is that * is reflexive transitive closure, contrary to the intuition that this concept should require quantifiers for its definition. Using this result we give several examples of dynamic algebras arising naturally in connection with additive functions, binary relations, state trajectories, languages, and flowcharts. The main result is that free separable dynamic algebras are residually separable-and-finite, important because finite separable dynamic algebras are isomorphic to Kripke structures. Applications include a new completeness proof for the Segerberg axiomatization of propositional dynamic logic, and yet another notion of regular algebra.

Algorithms for Scheduling Tasks on Unrelated Processors

2023-03-30T04:12:50Z
Algorithms for Scheduling Tasks on Unrelated Processors Davis, Ernest; Jaffe, Jeffrey M. Several algorithms are presented for the nonpreemptive assignment of n independent tasks to m unrelated processors. One algorithm requires polynomial time in n and m, and is at most 2√m times worse than optimal in the worst case. This is the best polynomial time algorithm known for scheduling such sets of tasks. An algorithm with slightly better worst case performance requires polynomial time in n but exponential time in m. This is the best algorithm known that requires time O(nlog(n)) for every fixed value of m.

Report on the Second Workshop on Data Flow Computer and Program Organization

2023-03-30T03:09:56Z
Report on the Second Workshop on Data Flow Computer and Program Organization Misunas, David P. The following report comprises an edited transcript of presentations made at the Workshop of Data Flow Computer and Program Organization, held at MIT on July 9-13, 1978, and co-sponsored by the Lawrence Livermore Laboratory (LLL) and the Department of Energy, Mathematical Sciences Branch. These informal transcriptions are only intended to provide a general picture of ongoing work in the area and to that end, have been heavily edited and summarized.

Timestamps and Capability-based Protection in a Distributed Computer Facility

2023-03-30T03:36:28Z
Timestamps and Capability-based Protection in a Distributed Computer Facility Wyleczuk, Rosanne H. This thesis investigates the problems of supporting security requirements and providing protection mechanisms in a distributed computer facility. The nature of the environment necessitates examination of operating systems, data base systems, and computer networks. The capability approach to providing protection in a centralized system is chosen as the foundation for the protection mechanism of the distributed system. The thesis also relies on an interesting approach to the representation of objects in a computer system. An object is represented by a sequence of immutable versions that represent the state of the object over time; each version is the result of an update on the object. This approach to describing objects provides the basis for a flexible definition of the world in which timestamps are naturally associated with every object in the system. The development of a DCF capability mechanism resulted in the following discoveries: Capabilities need not become immediately effective upon their generation. It is not necessary that the object to which access is being authorized exist at the time the capability is generated. And, the revocation of access privileges and the control of capability propagation are not insurmountable problems even in a distributed environment.

How to Share a Secret

2023-03-30T03:40:27Z
How to Share a Secret Shamir, Adi In this paper we show how to divide data D into n pieces in such a way that D is easily reconstructable from any k pieces, but even complete knowledge of k-1 pieces reveals absolutely no information about D. This technique enables the construction of robust key management schemes for cryptographic systems that can function securely and reliably even when misfortunes destroy half the pieces and security breaches expose all but one of the remaining pieces.

The Space Complexity of Two Pebbles Games on Trees

2023-03-30T03:02:07Z
The Space Complexity of Two Pebbles Games on Trees Loui, Michael C. In the standard pebble game the number of pebbles required to pebble the root of a tree can be computed in time linearly proportional to the number of nodes. For the black/white pebble game the number of pebbles necessary to pebble the root of a complete tree is derived.

Design of a Program for Expert Diagnosis of Acid Base and Electrolyte Disturbances

2023-03-30T03:42:38Z
Design of a Program for Expert Diagnosis of Acid Base and Electrolyte Disturbances Patil, Ramesh S. This research develops the diagnostic component of an interactive system for providing expert advice for the diagnosis, therapy and ongoing management of patients with acid-base and electrolyte disturbances. We have developed a hierarchic representation of a patient's illness which unifies the known facts about the patient, their suspected interrelationships, the hyptheses and how hypotheses account for various known and hypothesized facts. An expectation driven problem solver based on the hypothesize and reformulate paradigm performsn the diagnosis.

Time, Space and Randomness

2026-02-23T19:39:43Z
Time, Space and Randomness Adleman, Leonard M. Space and time are the fundamental parameters of complexity theory. The thesis of this paper is that randomness is of equal importance. We introduce a notion of randomness (based on Kologorov-Chaitin-Randomness), which we suspect will contribute to the understanding of some of the central problems in complexity theory. The purpose of this paper is primarily conceptual, though several easy theorems are given with clarify the relationship of this notion of randomness to the NP=P question, the complexity of integer factoring, and the sets computable in random polynomial time. Finally, using factoring as an example, we raise the possibility of performing experiments on functions of unknown complexity to indicate the extent of their tractability.

On the Cryptocomplexity of Knapsack Systems

2023-03-30T03:16:02Z
On the Cryptocomplexity of Knapsack Systems Shamir, Adi A recent trend in cryptographic systems is to base their encryption/decryption functions on NP-complete problems, and in particular on the knapsack problem. To analyze the security of these systems, we need a complexity theory which is less worst-case oriented and which takes into account the extra conditions imposed on the problems to make them cryptographically useful. In this paper we consider the two classes of one-to-one and onto knapsack systems, analyze the complexity of recognizing them and of solving their instances, introduce a new complexity measure (median complexity), and show that this complexity is inversely proportional to the density of the knapsack system. The tradeoff result is based on a fast probabilistic knapsack solving algorithm which is applicable only to one-to-one systems, and it indicates that knapsack-based cryptographic systems in which one can both encrypt and sign messages are relatively insecure.

Minimum Register Allocation is Complete in Polynomial Space

2023-03-30T03:09:30Z
Minimum Register Allocation is Complete in Polynomial Space Loui, Michael C. The Minimum Register Allocation Problem is to determine the minimum number of registers required to evaluate an arithmetic expression. A pebble game on directed acyclic graphs is used to prove that this is complete is complete in polynomial space.

A Network Traffic Generator for Decent

2023-03-30T03:03:14Z
A Network Traffic Generator for Decent Strazdas, Richard J. Computer network traffic generators provide a means for supplying benchmark results and for measuring computer network performance at all levels. Eventually they will also aid in fault diagnosis. The network traffic generator described in this thesis allows flexible yet convenient control over a number of parameters useful for generating loads over both test and real networks based on DEC's PDP-11 minicomputer. Implementation on a test network provides sample results. A discussion of design compromises, an recommendations for further study and design point to various open issues.

With what Frequency are Apparently Intractable Problems Difficult?

2023-03-30T03:16:32Z
With what Frequency are Apparently Intractable Problems Difficult? Meyer, A.R.; Paterson, M.S. An algorithm is almost polynomial-time (apt) iff there is a polynomial p such that for all n, the algorithm halts within p(n) steps on all by at most p(n) inputs of size at most n. It is nown that for NP-complete and polynomial space-complete problems, as well as certain other apparently intractable problems such as integer factoring, the following conditions are equivalent: (1) the problem is solveable by an apt algorithm, (2) the problem (or its complement) is polynomial-time transformable to a polynomial-sparse set, (3) the problem is solvable in polynomial time.

Metal Poker

2023-03-30T03:45:52Z
Metal Poker Shamir, Adi; Rivest, Ronald L.; Adleman, Leonard M. Can two potentially dishonest players play a fair game of poker without using any cards (e.g. over the phone)? This paper provides the following answers: 1. No. (Rigorous mathematical proof supplied. 2. Yes. (Correct & complete protocol given.)

Bicontinuous Extensions of Invertible Combinatorial Functions

2023-03-30T03:22:36Z
Bicontinuous Extensions of Invertible Combinatorial Functions Toffoli, Tommaso We discuss and solve the problem of constructing a diffeomorphic componentwise extension for an arbitrary invertible combinatorial function. Interpreted in physical terms, our solution constitutes a proof of the physical realizability of general computing mechanisms based on reversible primitives.

An Improved Proof of the Rabin-Harmanis-Stearns Conjecture

2023-03-30T03:10:01Z
An Improved Proof of the Rabin-Harmanis-Stearns Conjecture Perry, Harold M. We offer an improved presentation of Aanderaa's constructive proof of the Rabin-Hartmanis-Stearns conjecture: For all k≥2, there exists a language Lk such that Lk can be recoginzed by a k-worktape real time Turing machine but cannot be recognized by any (k-1)-worktape real time Turing machine.

Efficient Scheduling of Tasks Without Full Use of Processor Resources

2023-03-30T03:51:32Z
Efficient Scheduling of Tasks Without Full Use of Processor Resources Jaffe, Jeffrey The nonpreemptive scheduling of a partially ordered set of tasks on a machine with m processors of different speeds is studied. Heuristics are presented which benefit from selective non-use of slow processors. The performance of these heuristics is aymptotic of √m times worse than optimal, whereas demand driven schedules are unboundedly worse than optimal for any fixed value of m. The algorithms are extended to the situation where functionally dediciated processors must process tasks of a given type. Here, too, the worse case performance of the algorithms improves on the worst case performance of known algorithms. The techniques of analyzing these schedules are used to obtain a bound on a large class of preemptive schedules.

The Equivalence of R. E. Programs and Data Flow Schemes

2023-03-30T04:13:28Z
The Equivalence of R. E. Programs and Data Flow Schemes Jaffe, Jeffrey The Expressibe power of the data flow schemes of Dennis is evaluated. It is shown that data flow schemes have the power to express an arbitrary determinate functional. The proof involves a demonstration that "restricted data flow schemes" can simulate Turing Machines. This provides a new, simple basis for computability.

Operational Semantics of a Data Flow Language

2023-03-30T03:38:11Z
Operational Semantics of a Data Flow Language Brock, Jarvis D. A data flow machine achieves high performance by the concurrent execution of machine code consisting of data flow graphs which explicitly represent the data dependencies among program instructions. This thesis presents the operational semantics of ADFL, an applicative data flow language with an iteration construct resembling tail recursion and an error-handling scheme appropriate to the concurrency of data flow. The operation semantics O*T of ADFL are expressed by a two step process. The translation algorithm T maps an ADFL expression into its graph implementation, and the semantic function O maps the graph into its semantic characterization. Data flow graphs are specified by use of a graph assembly language, and the semantics of these graphs are derived by use of Kahn's fixpoint theory of communciating processes.

On the Security of the Merkle-Hellman Cryptographic Scheme

2023-03-30T04:07:28Z
On the Security of the Merkle-Hellman Cryptographic Scheme Shamir, Adi; Zippel, Richard E. In this paper we show that a simplified version of the Merkel-Hellman public-key cryptographic system is breakable. While their full-fledged system seems to be resistant to the cryptanalytic attack we propose, this result suggests some ways in which the security of their system can be further enhanced.

Data Model Equivalence

2023-03-30T04:11:11Z
Data Model Equivalence Borkin, Sheldon A. The current proliferation of proposals for database system data models and the desire for database systems which support several different data models raise many questions concerning "equivalence properties" of different data models. To answer these questions, one first needs clear definitions of the concepts under discussion. This paper presents formal definitions of the terms database, operation, operation type, application model and data model. Using this formal framework, database state equivalence, operation equivalence, application model equivalence and data model equivalence are distinguished. Three types of application and data model equivalence are defined - isomorphic, composed operation and state dependent. Possiblities for partial equivalences are mentioned. Implementation implications of these different equivalences are discussed. Examples are presented using two semantic data models, the semantic relation data model and the semantic graph data model.

Six Lectures on Dynamic Logic

2023-03-30T03:42:40Z
Six Lectures on Dynamic Logic Pratt, Vaughan R. The distinction made there between static and dynamic logic has a very simple character, yet can play a central and unifying role in logic as a vantage point from which one can compare propositional calculus, predicate calculus, intensional logics such as modal logic and temporal logic, various algorithmic logics (logics of programs) and Quine's notions of transparency and opacity.

Applications of Modal Logic to Programming

2023-03-30T03:27:00Z
Applications of Modal Logic to Programming Pratt, Vaughan R. The modal logician's notion of possible world and the computer scientist's notion of state of a machine provide a point of commonality which can form the foundation of a logic of action. Extending ordinary modal logic with the calculus of binary relations leads to a very natural logic for describing the behavior of computer programs.

Concurrent Programming

2023-03-30T04:20:20Z
Concurrent Programming Bryant, Randal E.; Dennis, Jack B.

Research Directions in Computer Architecture

2023-03-30T03:26:43Z
Research Directions in Computer Architecture Dennis, Jack B.; Fuller, Samuel H.; Ackerman, William B.; Swan, Richard J.; Weng, Kung-Song

A Near-optimal Method for Reasoning About Action

2023-03-30T04:09:58Z
A Near-optimal Method for Reasoning About Action Pratt, Vaughan R. We give an algorithm for "before-after" reasoning about action. The algorithm decides satisfiability and validity of formulae of propositional dynamic logic, a recently developed logic of change of state that subsumes the zero-order component of most other action-oriented logics. The algorithm requires time at most proportional to an exponentially growing function of the length (number of occurences of variabes and connectives) of the input. Fischer and Ladner have shown that that every algorithm for this problem must take exponential time, making this algorithm optimal to within a polynomial. No decision method for any other logic is known to be optimal to within less than an expoential. The typical time for our algorithm makes it a heuristically efficient algorithm of considerable pratical interest. Application areas incluse program verification, program synthesis, and discourse analysis. The algorithm is based on the method of semantic tableaux, appropriately generalized to dynamic logic. A novel treatment of Hintikka sets via theory algebras supplies the theoretical basis for our treatment of tableaux.

A Decidability Result for a Second Order Process Logic

2023-03-30T03:13:42Z
A Decidability Result for a Second Order Process Logic Parikh, Rohit We prove the decidability of the validity problem for a rather general language for talking about computations. As corollaries of our result, we obtain some decidability results of Pratt, Constable, Fischer-Ladner, and Pnueli and also a new decidability result for deterministic propositional dynamic logic.

Bounds on the Scheduling of Types Task Systems

2023-03-30T04:21:06Z
Bounds on the Scheduling of Types Task Systems Jaffe, Jeffrey M. We study the scheduling of different types of tasks on different types of processors. If there are k types of tasks and mi identifical processors for takss of type I, the finishing times of any demand driven or list schedule is at most k+1-(1/mas(m1,…,mk)) times worse than the optimal schedule. This bound is best possible. If the processors execute at different speeds then the performance ratio of any list schedule (relative to the optimal schedule) is bounded by k plus the maximum ratio between the speeds of any two processors of the same type.

An Analysis of Preemptive Multiprocessor Job Scheduling

2023-03-30T03:23:24Z
An Analysis of Preemptive Multiprocessor Job Scheduling Jaffe, Jeffrey M. The preemptive scheduling of a partially ordered set of tasks is studied. A class of scheduling heuristics is introduced, and the performance of schedules in this class is analyzed with respect to the least finishing time optimality criterion. If there are m processors, then the finishing time of any schedule in the class is at most √m + (1/2) times worse than optimal, independent of the speeds of the processors. Examples are given which indicate that there are schedules whcih may be as bad as √m-1 times worse than optimal even for machines with one fast processor.

Effectiveness

2023-03-30T03:26:10Z
Effectiveness Parikh, Rohit Church's thesis equates the intuitive notion "effective" with the mathematical notion "recursive." In order for this thesis to provide any information to us we have to have a clear understanding of both notions. We consider one of the prevalent definitions of "effective" and compare it with the notions of syntatic and semantic consequence to see whcih one it corresponds to better. The notion of syntactic consequence, while useful, is subservient to the semantic notion and when we go from one language to another we expect to have to change the syntatic notion of conseuqnce, if we are lucky enough to have one at all. Similiarly the prevalent notion of effectiveness is a restricted one and has had the effect of limiting our view. At the end of section 3, we give a more general analysis of effectiveness and propose a mathematical theory. In section 4 we consider the question whether the set of grammatical sentences of English is recursive. We show that this question is not well posed and that the arguments in favour of a positive answer are question begging. We reformulate this question in the form "How recursive is the set of grammatical sentences of English?", and propose a way of turning it into a precise technical problem. The method used is a generalisation of the Kolmogorov-Chaitin theory of randomness which is briefly sketched.

An Analysis of the Solovay and Strassen Test for Primality

2023-03-30T03:54:16Z
An Analysis of the Solovay and Strassen Test for Primality Baratz, Alan E. In this paper we will analyze the performace of the Solovay and Strasses probabilistic primality testing algorithm. We will show that iterating Solovay and Strassen's algorithm r times using independent random numbers at each iteration, results in a test for the primality of any positive odd integer, n>2, with error probability of 0 (if n is prime), error probability at most 4^-r (if n is composite and non-Carmichael), and error probability at most 2^-r (if n is composite and Carmichael).

A Fast Signature Scheme

2023-03-30T03:23:12Z
A Fast Signature Scheme Shamir, Adi In this paper we propose a new scheme for generating and verifying "electronic signatures" in public-key communications. The scheme is based on the difficulty of solving the knapsack problem, and its two main advantages over previous schemes are speed and simplicity.

A Completeness Result for a Propositional Dynamic Logic

2023-03-30T03:36:00Z
A Completeness Result for a Propositional Dynamic Logic Parikh, Rohit Propositional modal logic of programs has been introduced by Fischer and Ladner [1], following ideas of Pratt [4]. We shall call it propositional dynamic logic (PDL) following the terminology of Heral, Meyer and Pratt. In the following we prove the completeness of a rather natural set of axioms for this logic and for an extension of it obtained by allowing the inverse operation which converts a program into its inverse.

A Faster Algorithm Computing String Edit Distances

2023-03-30T03:47:04Z
A Faster Algorithm Computing String Edit Distances Masek, William J.; Patterson, Michael S. The edit-distance between two character strings can be defined as the minimum cost of a sequence of editing operations which transforms one string into the other. The operations allowed are deleteing, inserting and replacing one symbol at a time, with possibly different costs for each of these operations. The problem of finding the logest common subsequence of two strings is a special case of the problem of computing edit-distances. We describe an algorithm for computing the edit-distance between two strings of length n and m, n>=m, which requires 0(nm/min(log n, m)) steps whenever the costs of edit-operations are integral multiples of a single positive real number and the alphabet for the strings is finite. These conditions are necessary for the algorithm to achieve the time bound.

The Use of Queues in the Parallel Data Flow Evaluation of "If-Then-While" Programs

2023-03-30T03:36:43Z
The Use of Queues in the Parallel Data Flow Evaluation of "If-Then-While" Programs Jaffe, Jeffrey A property of a model of parallel computation is analyzed. We show that the use of queues may speed-up the execution of well formed data flow schemas by an arbitrarily large factor. A general model of data flow computation is presented to provide a framework for the comparison of data flow models. In particular a formal definition of a data flow version of the Computation Graphs of Karp and Miller and the Data Flow Schemas of Dennis are provided within the context of this model.

Arithemtical Completeness in Logics of Programs

2023-03-30T03:39:21Z
Arithemtical Completeness in Logics of Programs Harel, David We consider the problem of designing arithmetically complete axiom systems for proving general properties of programs; 1.e. axiom systems which are complete over arithmetical universes, when all first-order formulae which are valid in such universes are taken as axioms. We prove a general Theorem of Completeness which takes care of a major part of the responsibility when designing such systems. It is them shown that what is left to do in order to establish an arithmetical completeness result, such as those appearing in [12] and [14] for the logics of DL and DL+, can be described as a chain of reasoning which involves some simple utilizations of arithmetical induction. An immediate application of these observations is given in the form of an arithmetical completeness result for a new logic similar to that os Salwicki [22]. Finally, we contrast this discipline with Cook's [5] notion of relative completeness.

Lower Bounds on Information Transfer in Distributed Computations

2023-03-30T03:06:32Z
Lower Bounds on Information Transfer in Distributed Computations Abelson, Harold We derive a lower bound on the interprocessor information transfer required for computing a function in a distributed network. The bound is expressed in terms of the function's derivatives, and we use it to exhibit functions whose computation requires a great deal of interprocess communication. As a sample application, we give lower bounds on information transfer in the distributed computation of some typical matrix operations.

Descriptions and the Specialization of Concepts

2023-03-30T03:17:43Z
Descriptions and the Specialization of Concepts Martin, William A. The OWL II System computes with expressions which describe an object from a particular viewpoint. These partial descriptions form a tree structure under the specialization operation, which preserves intensional properties. The descriptions are also related in terms of their extensions by characterization and exemplar links. Descriptions of individuals must always specify a context of the description. Eight ways in which one description can be a specialization of another are distinguished.

A Computer Architecture for Data-flow Computation

2023-03-30T03:52:40Z
A Computer Architecture for Data-flow Computation Misunas, David P. The structure of a computer which utilizes a data-flow program representation as its base language is described. The use of the data-flow representation allows full exploitation by the processor of the parallelism and concurrency achievable through the data-flow form. The unique architecture of the processor avoids the usual problems of processor switching and memory/processor interconnection by the use of interconnection networks which has a great deal of inherent parallelism. The structure of the processor allows a large number of instructions to be active simultaneously. These active instructions pass through the interconnection networks concurrently and form streams of instructions for the pipelined functional units. Due to the cyclic nature of an iterative computation, the possiblity of deadlock can arise in the performance of such a computation within the data-flow architecture. A deadlock is caused by the interaction of several simultaneously active cycles of the same iterative computation. The use of a recursive rather than iterative representation of a computation avoids the deadlock problem and provides a more efficient implementation of the computation within the architecture. For this reason, a program executed by the data-flow processor is restricted to an acyclic directed graph representation.

The Subgraph Homeomorphism Problem

2023-03-30T04:18:47Z
The Subgraph Homeomorphism Problem LaPaugh, Andrea Suzanne The problem investigated in this thesis is that of finding homeomorphic images of a given graph, called the pattern graph, in a larger graph. A homeomorphism is a pair of mappings, (v,a), suc that v maps the nodes of the pattern graph to nodes of the larger graph, and a maps the edges of the mattern graph to (edge or node) disjoint paths in the larger graph. A homeomorphism represents a similarity of structure between the graphs involved. Therefore, it is an important concept for both graph theory and applications such as programming schema. We give a formal definition of the subgraph homeomorphism problem. In our investigation, we focus on algorithsm which depend on the pattern graph and allow the node mapping, v, to be partially or totally specified. Reductions between node disjoint and edge disjoint formulations of the problem are discussed. Also, reductions faciliating the solution of given subgraph homeomorphism problems are formulated. A linera time algorithm for finding a cycle in a graph containing three given nodes of the graph is presented. FInally, the two disjoint paths problem, an open problem, is discussed in detail.

Nondeterminism in Logics of Programs

2023-03-30T03:33:05Z
Nondeterminism in Logics of Programs Harel, David; Pratt, Vaughan R. We investigate the principles underlying reasoning about nondeterministic programs, and present a logic to support this kind of reasoning. Our logic, an extension of dynamic logic ([22] and [12]), subsumes most existing first-order logics of nondeterministic programs, including that developed by Dijkstra based on the concept of weakest precondition. A significant feature is the strict separation between the two kinds of nonterminating computations: infinite computations and failures. The logic has a Tarskian truth-value semanics, an essential prerequisite to establishing completeness of axiomatizations of the logic. We give an axiomatization for flowchart (regular) programs that is complete relative to arithmetic in the sense of Cook. Having a satisfactory tool at hand, we turn to the clarification of the concept of the total correctness of nondeterministic programs, providing in passing, a critical evaluation of the widely used "predicate transformer" approach to the definition of programming constructs, initiated by Dijkstra [5]. Our axiom system supplies a complete axiomatization of wp.

Computability and Completeness in Logics of Programs

2023-03-30T04:01:49Z
Computability and Completeness in Logics of Programs Harel, David; Meyer, Albert R.; Pratt, Vaughan R. Dynamic logic is a generalization of first order logic in which quantifiers of the form "for all X…" are replaced by phrases of the form "after executing program α…". This logic subsumes most existing first-order logic of programs that manipulate their environment, including Floyd's and Hoare's logics of partial correctness and Manna and Waldinger's logic of total correctness, yet is more closely related to classical first-order logic than any other proposed logic of programs. We consider two issues: how hard is the validity problem for the formulae of dynamic logic, and how might one axiomatize dynamic logic? We give bounds on the validity problem for some special cases, include a π0/2-completeness result for the partial correctness theories of uninterpreted flowchart programs and a π1/1-completeness result for unrestricted dynamic logic. We also demonstrate the completeness of an axiomatization of dynamic logic relative to arithmetic.

A Complete Axiomatic System for Proving Deductions About Recursive Programs

2023-03-30T03:37:48Z
A Complete Axiomatic System for Proving Deductions About Recursive Programs Harel, David; Pnueli, Amir; Stavi, Jonathan Denoting a version of Hoare's system for proving partial correctness of recursive programs by H, we present an extension D which may be thought of a H u {^,v,∃,∀} uH^-1, including the rules of H, four special purpose rules and inverse rules to those of Hoare. D is shown to be a complete system (in Cook's sense) for proving deductions of the form σ1.....σn ?σ over a language, the wff's of which are assertions in some assertion language L and partial correctness specifications of the form p{α}q. All valid formulae of L are taken as axioms of D. It is shown that D is sufficient for proving partial correctness, total correctness and program equivalence as well as other important properties of programs, the proofs of which are impossibel in H. The entire presentation is worked out in the framework of nondeterministic programs employing iteration and mutually recursive procedures.

Characterizing Second Order Logic with First Order Quantifiers

2023-03-30T03:01:55Z
Characterizing Second Order Logic with First Order Quantifiers Harel, David A language Q is defined and given semantics, the formulae of which are quantifier-free first-order matrices prefixed by combinations of finite partially ordered first-order quantifiers. It is shown that Q is equivalent in expressive power to second order logic by establishing the equivalence of alternating second order quantifiers and forming conjunctions of partially ordered first-order quantifiers.

A Dynamic Debugging System for MDL

2023-03-30T03:02:19Z
A Dynamic Debugging System for MDL Berez, Joel M. Program debugging is a time consuming process. Conventional debugging techniques and aids typically give the user a narrow view of the program's operation, making debigging difficult. A debugging system that would present a clear overall picture of a program's behavior and would be both flexible and simple to operate would be a valuable tool. Such a system was designed and implemented in and for MDL, a high-level applicative programming language. This report discusses: the design alternatives considered during the debigging system's design and implementation phases, the reasons for the resulting design choices, and the system attributes. A major attribute of the system (MEND) is that it does not simulate the program being debugged but instead monitors it from another process. This attribute results in a robust and viable debugging system, because MEND need not be modified in order to handle each new extension to MDL and/or each new user-defined primitive.

A Logic Design for the Cell Block of a Data-flow Processor

2023-03-30T03:47:09Z
A Logic Design for the Cell Block of a Data-flow Processor Amikura, Katsuhiko Recently studies on parallel computation architecture have yielded a new type of computer architecture known as the data-flow processor. As part of the effort in realizing the data-flow processor, a logic design for the Cell Block of the basic data-flow processor is proposed in this thesis. The resulting design has a modular structure which is derived from a top-down decomposition of the specification given in an Aechitecutere Description Language. The desired speed of operation of the Cell Block is obtained by exploiting the parallellism inherent in its operation. The logic design is carried out using electronic devices available commerically today, but is based on an aynchronous communciation protocol.

Report on the Workshop on Data Flow Computer and Program Organization

2023-03-30T03:02:53Z
Report on the Workshop on Data Flow Computer and Program Organization Misunas, David P. The following report comprises an edited transcript of presentations made at the Workshop of Data Flow Computer and Program Organization, held at MIT on July 10-14, 1977 and co-sponsored by the Lawrence Livermore Laboratory (LLL) and the Department of Energy, Mathematical Sciences Branch. These informal transcriptions are only intended to provide a general picture of ongoing work in the area and, to that end, have been heavily edited and summarized. For further details, the interested reader should consult the bibliography at the end of the report.

Factoring Numbers in 0(log n) Arithmetic Steps

2023-03-30T03:53:52Z
Factoring Numbers in 0(log n) Arithmetic Steps Shamir, Adi In this paper we show that a non-trivial factor of a composite number n can be found by performing arithmetic steps in a number proportional to the number of bits in n, and thus there are extremely short straight-line factoring programs. However, this theoretical result does not imply that natural numbers can be factored in polynomial time in the Turing-Machine model of complexity, since the numbers operated on can be as big as 2^cn^2, thus requiring exponentially many bit operations.

An Analysis of Computer Decentralization

2023-03-30T04:06:43Z
An Analysis of Computer Decentralization D'Oliveira, Cecilia R. This thesis is concerned with the recent trend toward decentralization of the computer facility. We conjecture that there are strong forces in many organizations leading towards decentralization, which have been held in check by technological and economic constraints that are beginning to relax. This conjecture is explored by analyzing approxiately forty case studies of decentralization decisions. The results indicate that (1) strong decentralization forces do exist in many organizations. The forces derived from these particular case studies are classified as either functional, economic, or psychological. (2) The drop in hardware costs allows decentralization to occur at the initiative of lower level managers. The consequences could include disintegration of the organization's information system. Decisions by lower level managers may overlook the technological constraints of decentralization, especially the problems of networking loosely coupled computers. This could result in a future inability to share data or programs amond organizational units. Because of the many functional advantages it provides, we do not feel that top level management should discourage decentralization. However, top level management must be aware that the technological constraints require that decentralization occur with their guidance and their perspective of the entire organization.

Measuring User Characteristics on the MILTICS System

2023-03-30T03:50:41Z
Measuring User Characteristics on the MILTICS System Rodriguez, Humberto, Jr. One of the problems in measuring the performance of a computer system is in defining its normal workload. In the case of timesharing systems, it is necessary to develop a behavioral model of the average user. This thesis presents a study of several parameter that characterize user behavior on the Multics timesharing system at MIT. Data was gathered by monitoring the logon sessions of three different groups of users. The results are presented and comparisons are made between the command usage of the groups. Some patterns of usage do appear in the results, but it is unclear if they can be applied in other situations. A probability distribution of the think time between commands is shown and compared with other distributions. The benchmark program currently used on the Multics system is also compared with the user model described in this study. The capability to monitor user behavior and characteristics is shown to be useful and worth installing in the system.

On Triangulations of a Set of Points in the Plane

2023-03-30T03:36:51Z
On Triangulations of a Set of Points in the Plane Lloyd, Error Lynn A set, V, of points in the plane is triangulated by a subset, T, of the straight line segments whose enpoints are in V, if T is a maximal subset such that the line segments in T intersect only at their endpoints. The weight of any triangulation is the sum of the Euclidean lengths of the line segments in the triangulation. We examine two problems involving triangulations. We discuss several aspects of the problem of finding a minimum weight triangulation among all triangulations of a set of points and give counterexamples to two published solutions to this problem. Secondly, we show that the problem of determining the existence of a triangulation in a given subset of the straight line segments whose endpoints are in V is NP-Complete.

Ancillary Reports: Kernel Design Project

2026-02-05T21:12:42Z
Ancillary Reports: Kernel Design Project Clark, David D; Saltzer, Jerome H.; Voydock, V.L.; Janson, P.A.; Hunt, D.H.; Forsdick, H.C.; Reed, D.P.; Frankston, R.M.; Mabee, R.F.

An Overview of OWL, A Language for Knowledge Representation

2023-03-30T03:01:19Z
An Overview of OWL, A Language for Knowledge Representation Szolovits, Peter; Hawkinson, Lowell B.; Martin, William A. We describe the motivation and overall organization of the OWL language for knowledge representation. OWL consists of a memory of concepts in terms of which all English phrases and all knowledge of an application domain are represented, a theory of English grammar which tells how to map English phrases into concepts, a parser to perform that mapping for individual sentences, and an interpreter to carry out procedures which are written in the same representational formalism. The system has been applied to the study of interactive dialogs, explanations of its own reasoning, and question answering.

Finding Minimum Cutsets in Reducible Graphs

2023-03-30T03:59:00Z
Finding Minimum Cutsets in Reducible Graphs Shamir, Adi The analysis of many processes modelled by directed graphs requires the selection of a subset of vertices which cut all the cycles in the graph. Reducing the size of such a cutset usually leads to a simpler and more efficient analysis, but the problem of finding minimum cutsets in general directed graphs is know to be NP-complete. In this paper we show that in reducible graphs (and thus in almost all the "practicla" flowcahrts of programs), minimum cutsets can be found in linear time. An immediate application of this result is in program verification systems based on Floyd's inductive assertions method.

The Mutual Exclusion Problem for Unreliable Processes

2023-03-30T03:15:59Z
The Mutual Exclusion Problem for Unreliable Processes Rivest, Ronald L.; Pratt, Vaughan R. Consider n processes operating asynchronously in parallel, each of which maintains a single "public" variable which can be read (but not written) by the other processes. We show that the processes can synchronize their actions by the basic operations of (1) reading each other's public variables, and (2) setting their own public variable to some value. A process may "die" (fail) at any time, when its public variable is (automatically) set to a special "dead" value. A dead process may revive. Reading a public variable which is being simultaneously updated returns either the old or the new value. Each process may be in a certain "critical" state (which it leaves if it dies). We present a synchronization scheme with the following properties. (1) At most one process is ever in its critical state at a time. (2) If a process wants to enter its critical state, it may do so before any other process enters its critical state more than once. (3) The public variables assume only a finite number of values. (4) A process wanting to enter its critical state can always make progress towards that goal. (5) The various processes may run arbitrary speeds relative to one another. By the definition of the problem, no process can prevent another from entering its critical state by repeatedly failing and restartying. In the case of two processes, what makes our solution of particular interest is its remarkable simplicity when compared with the extant solutions to this problem. Our n-process solution uses the two-process solution as a subroutine, and is not quite as elegant as the two-process solution.

Construction and Analysis of Network Flow Problem Which Forces Karzanov Algorithm 0(n^3) Running Time

2023-03-30T03:37:21Z
Construction and Analysis of Network Flow Problem Which Forces Karzanov Algorithm 0(n^3) Running Time Baratz, Alan E. The intest of this paper is to demonstrate the construction of a network flow problem which will force the Karzanov "Preflow" algorithm to run in its theoretic worst case time 0(n^3). Once such a "bad case" network has been constructed, an analysis is performed to determine the exact time required by the algorithm to computer the maximum flow through the network.

A Method for Obtaining Digital Signatures and Public-key Cryptosystems

2023-03-30T03:36:07Z
A Method for Obtaining Digital Signatures and Public-key Cryptosystems Rivest, Ronald L.; Shamir, Adi; Adleman, Len We present an encryption method with the novel property that publicly revealing an encryption key does not thereby reveal the corresponding decryption key. This has two important consequences. 1. Couriers or other secure means are not needed to transmit keys, since a message can be enciphered using an excryption key publicly revealed by the inteded recipient. Only he can decipher the message, since only he knows the corresponding decryption key. 2. A message can be "signed" using a privately-held decryption key. Anyone can verify this signature using the corresponding publicly revealed encryption key. Signatures cannot be forged, and a signer cannot later deny the validity of his signature. This has obvious applications in "electronic mail" and "electronic funds transfer" systems. A message is encrypted by representing it as a number M, raising M to a publicly-specified power e, and then taking the remainder when the result is dividied by the publicly specified product n of two large secrete prime numbers p and q. Decryption is similar; only a different sectre, power d is used, where e*d=1(modp-1)*(q-1)). The secruity of the system rests in part on the difficulty of factoring the published divisor, n.

Hardware Estimatino of a Process' Primary Memory Requirements

2023-03-30T03:13:13Z
Hardware Estimatino of a Process' Primary Memory Requirements Gifforf, David K. It is shown that a process' primary memory requirements can be approximated by use of the miss rate in the Honeywell 6180's page table word associative memory. This primary memory requirement estimate was employed by an experimental version of Multics to control the level of multiprogramming in the system, and bill for memory usage. The resultant system's tuning parameters were shown to be configuration insensitive, and it was conjectured that the system would also track shifts in the referencing characteristics of its workload and keep the system in tune. The limitations of the assumptions made about a process' referencing characteristics are examined, and directions for future research are outlined.

The Max Flow Algorithm of Dinis and Karzanov: An Exposition

2023-03-30T03:06:42Z
The Max Flow Algorithm of Dinis and Karzanov: An Exposition Even, Shimon Recently A.V. Karzanov improved Dinic's algorithm to run in time 0(n^3) for networks of n vertices. For the benefit of those who do not read Russian, the Dinic-Karzanov algorithm is explained and proved. In addition to being the best algorithm known for network flow, this algorithm is unique in that it does not use path augmentation.

A System to Process Dialogue: A Progress Report

2023-03-30T03:45:34Z
A System to Process Dialogue: A Progress Report Brown, Gretchen P. This is a progress report on work toward and English language interface for expert systems. A framework for handling mixed-initiative English dialogue in a console session environment is discussed, with special emphasis placed on recognition. The ideas presented here are being implemented in a prototype system called Susie Software, which is embedded in the OWL system. OWL is currently under development in the Automatic Programming Group at the MIT Laboratory for Computer Science. We are using OWL to explore the problems of constructing expert systems, and for Susie Software the domain of expertise is programming. In the Susie effort to date, major emphasis has been placed on the construction of a computational model for the structural aspects of English dialogue; it is this structural model that will be discussed.

Improving Information Storage Reliability Using a Data Network

2023-03-30T04:16:56Z
Improving Information Storage Reliability Using a Data Network Benjamin, Arthur J. Backup and recovery methods using magnetic tapes are common in computer utilities, since information stored on-line is subject to damage. The serial access nature of the tape medium severely restricts the flexibility and simplicity of accessing and managing the stored data. A method using a data network will be described, to present a backup mechanism which takes advantage of a large, inexpensive, random access remote data storage facility to provide data access and management functions that are more flexible than. those provided by a traditional backup facility. Although data transfer rates will be reduced, data access and management will be simplified, and system availability will be improved. The work described is based on a network backup facility built for the Multics computer utility, using the ARPAnet.

Task Scheduling in the Control Robotics Environment

2023-03-30T04:18:20Z
Task Scheduling in the Control Robotics Environment Mok, Aloysius Ka-Lau Scheduling problems involved in Control Robotics, a software approach to control engineering are studied. The capability of a multiprocessor system to handle tasks with hard, real-time deadlines is investigated according to whether complete or partial a priori knowledge of the deadlines, computation times and frequencies of occurence of individual tasks is available. A model of preemptive scheduling, the "scheduling game" is introduced to explore mathematical relationships for different scheduling situations. A necessary and sufficient condition for scheduling tasks with simultaneous requests or deadlines is derived. Partial solutions and the difficulties involved in scheduling tasks with distributed requests are discussed. It is shown that in the most general case, there is no globally optimal algorithm in the absense of a priori knowledge about the distribution of requests of future tasks in time.

A Note on the Average Time to Compute Transitive Closures

2023-03-30T03:46:50Z
A Note on the Average Time to Compute Transitive Closures Bloniarz, P.A.; Fischer, M.J.; Meyer, A.R.

K+1 Heads are Better Than K

2023-03-30T03:35:54Z
K+1 Heads are Better Than K Yao, Andrew C.; Rivest, Ronald L. There are languages which can be recognized by a deterministic (k+1)-headed one-way finite automaton but which cannot be recognized by a k-headed one-way (deterministic or non-deterministic) finite automaton. Furthermore, there is a language accepted by a 2-headed nondeterministic finite automaton which is accepted by no k-headed deterministic finite automaton.

The Design of a Modular Laboratory for Control Robotics

2023-03-30T03:49:58Z
The Design of a Modular Laboratory for Control Robotics Malvania, Nikhil Computer have been used for the control of physical processes since the early sixties. In this thesis, we look at Control Robotics, the procedural control of physical processes. Based upon this new approach, a design for a modular laboratory is proposed. The laboratory consists of a set of experiments which can be synthesized using certain conversion and processing modules. The laboratory also entails the generation of algorithms and programs for each experiement. Experiments are proposed and analysed, and a common and in a sense, minimal set of hardward modules is selected using a minimax approach. Power, torque, strength, resolution and other similar requirements for the modules are discussed. A theoretical model is developed for predicting and analyzing the capability of a processor to perform real-time control. The model is based upon the so-called Earliest Deadline algorithm for scheduling a number of tasks on a single processor. The model relates the bandwidths of different tasks a processor can perform to the total number of tasks; the average instruction execution time for the processor; and the complexity of its instruction set. This model is used to exhibit and compare the controlling capacities of two processors - Digital Equipment Corporation's PDP 11/45 and Intel 8080. It is also used to predict the processor requirements for the experiments of the proposed modeular laboratory. Thesis results include measure of relative power of the tested processors in the context of real-time control, and their capabilities in carrying out the experiments of the proposed laboratory.

Optimal Arrangement of Keys in a Hash Table

2023-03-30T03:13:36Z
Optimal Arrangement of Keys in a Hash Table Rivest, Ronald L. When open addressing is used to resolve collisions in a hash table, a given set of keys may be arranged in many ways; typically this depends on the order in which the keys are inserted. We show that arrangements minimizing either the average or worst-case number of probes required to retrieve any key in the table can be found using an algorithm for the assignment problem. The worst-case retrieval time can be reduced to 0(log2(M)) with probability 1-E(M), when storing M keys in a table of size M, where E(M) -> 0 aas M -> infinity. We also examine insertion algorithms to see how to apply these ideas for a dynamically changing set of keys.

Protosystem I: An Automatic Programming System Prototype

2023-03-30T04:19:25Z
Protosystem I: An Automatic Programming System Prototype Ruth, Gregory R. A model of the data processing system writing process is given in terms of development stages. These stages correspond to the progression in the implementation and design process from the highest level of abstraction (English system specifications) to the lowe level (machine code). The issues and goals (including optimization of the product data processing systems) involved in automating these stages are discussed and strategies and methodologies used for doing so are developed. Protosystem I, an automatic programming system prototype, is described. The completed (and working) part automates three of the five stages identified in the proposed model of the system writing process. The basic theory, methods and structure of this part of the automatic programming systems are presented.

On the Worst-case Behavior of String-searching Algorithms

2023-03-30T04:24:39Z
On the Worst-case Behavior of String-searching Algorithms Rivest, Ronald L. Any algorithm for finding a pattern of length k in a string of length n must examine at least n-k+1 of the characters of the string in the worst case. By considering the pattern 00…0, we prove that this is the best possible result. Therefore there do not exist pattern matching algorithms whose worst-case behavior is "sublinear" in n (that is, linear with constant less than one), in contrast with the situation for average behavior (the Boyer-Moore algorithm is known to be sublinear on the average).

Automatic Design of Data Processing Systems

2023-03-30T04:08:53Z
Automatic Design of Data Processing Systems Ruth, Gregory R. The design of data organization and data accessing procedures for data processing systems operating on large keyed fields of data is a common and recurrent activity in modern data processing applications. A considerable amount of understanding and expertise in this area has been developed and it is time to being codifying and automating this process. It should be possible to develop a system where the user has merely to specify the characteristics of his data objects and their interrelations and the system will automatically determine the data organizations and accessing procedures that are optimal for his application. The optimizer for Protosystem I (an automatic programming system prototype at MIT) provides an example of how such automation can be accomplished.

Improved Bounds on the Costs of Optimal and Balanced Binary Search Trees

2023-03-30T03:02:03Z
Improved Bounds on the Costs of Optimal and Balanced Binary Search Trees Bayer, Paul J. A binary search tree can be used to store data in a computer system for retrieval by name. Different elements in the tree may be referenced with different probabilities. If we define the cost of the tree as the average number of elements which must be examined in searching for an element, then different trees have different costs. We show that two particular types of trees, weight balanced trees and min-max trees, which are easily constructed from the probability distribution on the elements, are close to optimal. Specifically, we show that for any probability distribution with entropy H, H-log2H-(log2e-1)<=Copt<= Cwb ,+ H+2/Cmm,+H+2 where Copt, Cwb, and Cmm are the optimal, weigh balances, and min-max costs. We gain some added insight by deriving an expression for the expected value of the entropy of a random probability distribution.

Steam-oriented Computation in Recursive Data Flow Schemas

2023-03-30T03:50:23Z
Steam-oriented Computation in Recursive Data Flow Schemas Weng, Kung-Song In this thesis we present a parallel programming language based on a parallel computation model known as data flow schemas. Syntactically, the language resembles programming languages such as Algol 60, but does not have GOTO's, WHILE-loops, and non-local variables. The attractiveness of this approach lies in the inherently determinate nature of data flow schemas and the possiblity of formalizing the semantics of the language within the formalism suggested by Scott and Strachey. The language provides programming features for stream-oriented computation and intercommunicating systems. We introduce the notions of proper initialization and termination of such systems. A subclass of determinate systems in which these properties can be easily checked is defined and a translation into recursive data flow schemas is given.

Computational Complexity of the Word Problem for Commutative Semigroups

2023-03-30T03:17:59Z
Computational Complexity of the Word Problem for Commutative Semigroups Cardoza, Edward W. We analyze the computational complexity of some decision problems for commutative semigroups in terms of time and space on a Turing machine. The main result we present is that any decision procedure for the word problemm for commutative semigroups requires storage space at least proportional to n/logn on a multitape Turing machine. This implies that the word problem is polynomia space hard (and in particular that it is at least NP-hard). We comment on the close relation of commutative semigroups to vector addition systems and Petri nets. We also show that the lower bound of space n/logn can be extended to certain other natural algorithmic problems for commutative semigroups. Finally we show that for several other algorithmic problems for commutative semigroups there exist polynomial time algorithms.

Formal Properties of Well-formed Data Flow Schemas

2023-03-30T03:49:40Z
Formal Properties of Well-formed Data Flow Schemas Leung, Clement Kin Cho This thesis presents some results in comparative schematology and some undecidability results for two models of computer programs: the class of flowchart schemas and the class of well-formed data flow schemas (wfdfs's). Algorithms are given for translating a schema in each class into an equivalent schema in the other class. The propertiees of freedom, _-freedom, openness, and completeness are defined and studied. For every path P in a free flowchart schema S, there exists an interpretation under which the flow of controls through S is along P. _-freedom is a generalization of freedom and captures the notion of freedom for wfdfs's. An open schema is one in which no basic component is redundant and a complete schema contains no subschema which, whenever enabled, does not terminate. A comparison of the expressive power of subclasses of flowchart schemas and wfdfs's possessing various combinations of these properties is made. It is shown that the class of free flowchart schemas properly contains the classes of free and _-free wfdfs's , and that the class of open and complete flowchart schemas is equivalent in expressive power to the class of open and complete wfdfs's. Three undecidabilty results for open and complete program schemas are established: openness is undecidable for complete program schemas, completeness is undecidable for open program schemas, and equivalence is undecidable for open and complete program schemas.

The Complexity of Negotion-limited Networks: A Brief Survery

2023-04-07T15:42:39Z
The Complexity of Negotion-limited Networks: A Brief Survery Fischer, Michael J.

Finding Isomorph Classes for Combinatorial Structures

2023-03-30T04:13:01Z
Finding Isomorph Classes for Combinatorial Structures Weiss, Randell B. A common problem in combinatorial analysis is finding isomorph classes of combinatorial objects. This process is sometimes known as isomorph rejection. In graph theory, it is used to count labelled and unlabelled graphs with certain properties. In chemistry, it is used to count the number of structures with the same chemical formula. In computer science it is used in counting arguments in proofs in complexity theory. In coding theory, it is used to partition sets of vectors into easy to handle sets. This thesis presents three different algorithms for solving this type of problem and compares their timing and memory use. Some examples are given of how to apply the algorithms to graph theory and coding theory.

Encryption Schemes for Computer Confidentiality

2023-03-30T03:36:09Z
Encryption Schemes for Computer Confidentiality Pless, Vera

An Asynchronous Logic Array

2023-04-07T15:40:08Z
An Asynchronous Logic Array Patil, Suhas S. A new asynchronous logic array for the general synthesis of asynchronous digital circuits is presented. The parallel and asynchronous nature of the array gives the realized systems the speed and characteristics of hardwired circuits even though they are implemented in a uniform diode array with appropriate terminating circuits. The logic array is particularly suited for implementing control structures and should help extend the field of micro-control to asynchronous and parallel computers.

First Version of a Data Flow Procedure Language

2023-03-30T03:48:17Z
First Version of a Data Flow Procedure Language Dennis, Jack B. A language for representing computational procedures based on the concept of data flow is presented in terms of a semantic model that permits concurrent execution of noninterfering program parts. Procedures in the language operate on elementary and structured values, and always define functional transformations of values. The language is equivalent in expressive power to a block structured language with internal procedure variables and is a generalization of pure Lisp. The language is being used as a model for study of fundamental semantic constructs for programming, as a target language for evaluating translatability of programs expressed as the user-language level, and as a guide for research in advanced computer architecture.

CAMAC: Group Manipulation System

2023-03-30T04:00:03Z
CAMAC: Group Manipulation System Weiss, Randell B. CAMAC is a collection of group manipulation progams with an easy to use interface. With groups defined by either generating permutations or generators and relations the system can find coset tables, normalizers, centralizers, stabilizers, orbits, conjugacy classes, and isomorph classes of combinatorial objects, etc.

Decision Problems for Petri Nets and Vector Addition Systems

2023-03-30T03:58:27Z
Decision Problems for Petri Nets and Vector Addition Systems Hack, Michael Petri Nets, Generalized Petri Nets, and Vector Addition Systems can represent each other and thus have common decideability problems. The graphical appeal of Petri Nets is used in a new presentation of the classical problems of boundedness (decidable) and inclusion (undecidable). Various forms of the Reachability Problem are shown to be recursively equivalent to the Liveness Problem for Petri Nets. The decideability of these questions is still open, and some arguments both for and against the decidability of Liveness are presented.

Decidability of Equivalence for a Class of Data Flow Schemas

2023-03-30T03:30:07Z
Decidability of Equivalence for a Class of Data Flow Schemas Qualitz, Joseph E. In this paper we examine a class of computation schemas and consider the problem of deciding when pairs of elements in this class represent equivalent programs. We are able to show that equivalence is decidable for a non-trivial class of unary operator data flow schemas, and consider the applicability of this result to the problem of deciding equivalence in related models of computation. The model described below is a restricted version of the data flow schema described by Dennie and Fosseen in [1]. The reader is referred to that source for a more complete discussion of the properties of data flow schemas.

On Bateson's Logical Levels of Learning Theory

2023-03-30T03:39:24Z
On Bateson's Logical Levels of Learning Theory Levin, Michael

Research on Experts Systems

2023-03-30T03:04:57Z
Research on Experts Systems Gorry, G. Anthony

A Class of Boolean Functions with Linear Combinatorial Complexity

2023-04-07T15:16:44Z
A Class of Boolean Functions with Linear Combinatorial Complexity Hsieh, W. N.; Harper, L.H.; Savage, J.E. In this paper we investigate the combinatorial complexity of Boolean functions satisfying a certain property, P^nk,m. A function of n variable has the P^nk,m property if there are at least m functions obtainable from each way of restricting it to a subset of n-l variables. We show that the complexity of P^n3,5 function is no less than 7n-4/6, and this bound cannot be much improved. Further, we find that for each k, there are p^k,2^k functions with complexity linear in n.

The Inherent Computational Complexity of Theories of Ordered Sets: A Brief Survery

2023-03-30T03:07:33Z
The Inherent Computational Complexity of Theories of Ordered Sets: A Brief Survery Meyer, Albert R.

MDC-Programmer: A Muddle-to-datalanguage Translator for Information Retrieval

2023-03-30T03:44:01Z
MDC-Programmer: A Muddle-to-datalanguage Translator for Information Retrieval Bengelloun, Safwan A. This memo describes a practical application within the framework of the ARPA computer network of the philosophy that a fully developed computer network should appear as a virtual extensino of the user's own software environment. The application involves the design and implementation of a software facility that will permit users at MIT's Dynamic Modeling System to consider the retrieval component of the Datacomputer (developed and run by the Computer Corporation of America) as an extension of the Muddle environment. This facility generates efficient Datalanguage retrieval code, handles inter-process control of the Datacomputer, and manages all the necessary network connections.

Computing in Logarithmic Space

2023-03-30T03:49:04Z
Computing in Logarithmic Space Lind, John C. The set logspace, of logarithmic space computable string functions is defined. It is easily seen that logspace ≤ polytime, the set of polynomial time computable functions. ogspace is shown to equal L, the smallest class of recursive string functions containing concatenation and the equality function, and closed under explicit transformation, substitution of a function for a variable and two restricted types of recursion on notation. The first is called recursion of concatenation and only allows top level concetenation of the value of the recursive call. The second, called log bounded recursion on notation, will only define string functions whose length is bounded by 0(log n) on arguments of length n. Some additional closure properties of logspace are also described.

An Investigation of Current Language Support for the Data Requirements of Structured Programming

2023-03-30T03:02:27Z
An Investigation of Current Language Support for the Data Requirements of Structured Programming Aiello, Jack M. Structured programming is a new method for constructing reliable programs. Structured programming relies upon a systematic technique of top-down development which involves the refinement of both control structures and data structures. With possibly some limitations and extensions, existing languages can support control structure refinement. On the other hand, it is the belief of many that the representation of data structure refinement cannot be satified by present-day languages. Before accepting this view, it is wise to explore its validity. Therefore this thesis will investigate whether existing languages with possibly slight modifications are adequate for supporting the data requirements of structured programming.

An Enciphering Module for Multics

2023-03-30T03:38:12Z
An Enciphering Module for Multics Benedict, G. Gordon Recently IBM Corporation has declassified an algorithm for encryption usable for computer-to-computer or computer-to-terminal communications. Their algorithm was implemented in a hardware device called Lucifer. A software implementation of Lucifer for Multics is described. A proof of the algorithm's reversibility for deciphering is provided. A special hand-coded (assembly language) version of Lucifer is described whose goal is to attain performance as close as possible to that of the hardward device. Performance measurements of this program are given. Questions addressed are: How complex is it to implement an algorithm in software designed primarily for digital hardware? Can such a program perform well enough for use in the I/O system of a large time-sharing system?

Complete Classification of (24,12) and (22,11) Self-dual Codes

2023-03-30T03:39:55Z
Complete Classification of (24,12) and (22,11) Self-dual Codes Pless, Vera; Sloane, N.J.A. A complete classification is given of all [22, 11] and [24, 12] self-dual codes. For each code we give the order of its group, the number of codes equivalent to it, and its weight distribution. There is a unique [24, 12, 6] self-dual code. Several theorems on the enumeration of self-orthogonal codes are used, including forumlas for the number of such codes with minimum distance ≥ 4, and for the sum of the weight enumerators of all self-dual codes.

The Reduction Method for Establishing Lower Bounds on the Number of Additions

2023-03-30T04:13:05Z
The Reduction Method for Establishing Lower Bounds on the Number of Additions Kedem, Zvi M. A method for establishing lower bounds on the number of multiplications and divisions has been developed by Pan, Winograd and Strassen. A similar method is developed for establishing lower bounds on the number of additions and subtractions. The results obtained partially overlap those of Belaga, Winograd and Kirkpatrick.

Combining Dimensionality and Rate of Growth Arguments for Establishing Lower Bounds on Number of Multiplications

2023-03-30T03:19:03Z
Combining Dimensionality and Rate of Growth Arguments for Establishing Lower Bounds on Number of Multiplications Kedem, Zvi M. In this paper we describe a new method for establishing lower bounds for the number of multiplications and divisions required to compute rational functions. We shall start by reminding the reader of some standard notations.

Fast On-line Integer Multiplication

2023-03-30T03:39:47Z
Fast On-line Integer Multiplication Fischer, Michael J.; Stockmeyer, Larry J. A Turing machine multiplies binary integers on-line if it receives its inputs low-order digits first and produces the jth digit of the product before reading in the (j+l)st digits of the two inputs. We present a general method for converting any off-line multiplication algorithm which forms the product of two n-digit binary numbers in time F(n) into an on-line method which uses time only O(F(n) log n ), assuming that F is monotone and satisfies n F(n) F(2n)/2 ! kF(n) for some constant k.

Symmetry Codes and Their Invariant Subcodes

2023-03-30T03:28:37Z
Symmetry Codes and Their Invariant Subcodes Pless, Vera We define and study the invariant subcodes of the symmetry codes in order to be able to determine the algebraic properties of these codes. An infinite family of self-orthogonal rate 1/2 codes over GF (3), called symmetry codes, were constructed in [3].

Super-exponential Complexity of Presburger Arithmetic

2023-03-30T04:09:05Z
Super-exponential Complexity of Presburger Arithmetic Fischer, Michael J.; Rabin, Michael O. Lower bounds are established on the computational complexity of the decision problem and on the inherent lengths of proofs for two classical decidable theories of logic: the first order theory of the real numbers under addition, and Presburger arithmetic -- the first order theory of addition on the natural numbers. There is a fixed constant c > 0 such that for every (non-deterministic) decision procedure for determining the truth of sentences of real addition and for all sufficiently large n, there is a sentence of length n for which the decision procedure runs for more than 2 cn steps.

On the Complexity of the Theories of Weak Direct Products

2023-03-30T03:24:26Z
On the Complexity of the Theories of Weak Direct Products Rackoff, Charles Let N be the set of nonnegative integers and let < N ,+> be the weak direct product of < N,+> with itself. Mostowski[ 9 ] shows that the theory of < N ,*> is decidable, but his decision procedure isn't elementary recursive. We present here a more efficient procedure which operates within space 2 2 . As corollaries we obtain the same upper bound for the theory of finite abelian groups, the theory of finitely generated abelian groups, and the theory of the structure < N ,' > of positive ...

String-matching and Other Products

2023-03-30T03:14:08Z
String-matching and Other Products Fischer, Michael J.; Paterson, Michael S. The string-matching problem considered here is to find all occurrences of a given pattern as a substring of another longer string. When the pattern is simply a given string of symbols, there is an algorithm due to Morris, Knuth and Pratt which has a running time proportional to the total length of the pattern and long string together. This time may be achieved even on a Turing machine. The more difficult case where either string may have "don't care" symbols which are deemed to match with all symbols is also considered. By exploiting the formal similarity of string-matching with integer multiplication, a new algorithm has been obtained with a running time which is only slightly worse than linear.

An Improved Overlap Argument for On-line Multiplication

2023-03-30T03:01:48Z
An Improved Overlap Argument for On-line Multiplication Paterson, Michael S.; Fischer, Michael J.; Meyer, Albert R. A lower bound of cN1ogN is proved for the mean time complexity of an on-line multitape Turing machine performing the multiplication of N-digit binary integers. For a more general class of machines the corresponding bound is cN1ogN. These bounds compare favorably with know upper bounds of the form cN(1ogN) k, and for some classes the upper and lower bounds coincide. The proofs are based on the "overlap" argument due to Cook and Aanderaa.

Discrete Computation: Theory and Open Problems

2023-03-30T03:37:13Z
Discrete Computation: Theory and Open Problems Meyer, Albert R. Complexity 1. Borodin, A. Computational Complexity: Theory and Practice, in Currents in the Theory of Computing, A. Aho, ed., Prentice-Hall, Englewood Cliff, N.J., 1973,pp.32-89.

Weak Monadic Second Order Theory of Successor is not Element-recurive

2023-03-30T03:30:17Z
Weak Monadic Second Order Theory of Successor is not Element-recurive Meyer, Albert R. Let L SIS be the set of formulas expressible in a week monadic second order logic using only the predicates [x =y+1] and [x E z]. Bucci and Elgot [3,4] have shown that the truth of sentences in L SIS (under the standard interpretation < N, successor > with second order variables interpreted as ranging over finite sets) is decidable. We refer to the true sentences in L SIS as WSIS. We shall prove that WSIS is not elementary-recursive in the sense of Kalmar. In fact, we claim a stronger result:

Real-time Simulation of Multidimensional Turing Machines by Storage Modification Machines

2023-03-30T03:12:19Z
Real-time Simulation of Multidimensional Turing Machines by Storage Modification Machines Schönage, A. In [1] the author introduced a new machine model, now called the Storage Modification Machine (SMM). It was claimed, but not proved, that SMM's can simulate all sorts of Turing machines-- those with multidimensional worktapes in particular -- in real time.

A User's Guide to the Macro Control Language

2023-03-30T03:20:09Z
A User's Guide to the Macro Control Language Geiger, Steven P.

An Interactive Implementation of the ToddCoxeter Algorithm

2023-04-07T15:02:26Z
An Interactive Implementation of the ToddCoxeter Algorithm Bonneau, Richard J. The Todd-Coxeter algorithm provides a systematic approach to the enumeration of cosets of a finitely presented group. This memo describes an interactive implementation of algorithm, including a manual on its use, examples, and methods of accessing the program. Applications of this algorithm are also discussed.

Polynomial Exponentiation: The Fast Fourier Transform Revisited

2023-03-30T03:52:38Z
Polynomial Exponentiation: The Fast Fourier Transform Revisited Bonneau, Richard J.

A Decision Procedure for the First Order Theory of Real Addition with Order

2023-03-30T04:25:44Z
A Decision Procedure for the First Order Theory of Real Addition with Order Ferrante, Jeanne; Rackoff, Charles Consider the first order theory of the real numbers with the predicates + (plus) and < (less than). Let S be the set of true sentences. We first present an elimination of quantifiers decision procedure for S, and then analyse it to show that it takes at most time 2^2^cn, c a constant, to decide sentences of length n. Looking more closely at this procedure, we arrive at a second procedure by showing that a given sentence doesn't change in truth value when each of the quantifiers is limited to range over an appropriately chosen finite set of rationals. This fact leads to a decision procedure for S which takes space2^cn. We also remark that our methods lead to a decision procedure for Presburger arithmetic which operates in space 2^2^cn. These upper bounds should be compared with the results of Fischer and Rabin (Proceedings of AMS Symp. on Complexity of Real Computation Processes, to appear) that for some constant c, tim 2^cn for real addition, and time 2^2^cn for Presburger arithmetic, is required to decide some sentences of length n for infitely many n.

An Operator Embedding Theorem for Complexity Classes of Recursive Functions

2023-03-30T03:00:58Z
An Operator Embedding Theorem for Complexity Classes of Recursive Functions Moll, Robert Let F (t) be the set of functions computable by some machine using no more than t(x) machine steps on all but finitely many arguments x. If we order the - classes under set inclusion as t varies over the recursive functions, then it is natural to ask how rich a structure is obtained. We show that this structure is very rich indeed. If R is any countable partial order and F is any total effective operator, then we show that there is a recursively enumerable sequence of...

A Class of Finite Computations Structures Supporting the Fast Fourier Transform

2023-03-30T03:05:31Z
A Class of Finite Computations Structures Supporting the Fast Fourier Transform Bonneau, Richard J. The Fast Fourier Transform (FFT) and modular arithmetic are two distinct techniques which recently have been employed to increase the efficiency of numerous algorithms in the area of symbolic and algebraic manipulation.

SIM360: A S/360 Simulator

2023-03-30T03:38:44Z
SIM360: A S/360 Simulator McCray, Wm. Arthur Modern, large-scale computer systems typically operate under the control of an operating system or executive program, and reserve for the exclusive use of the operating system a set of privileged instructions, which the normal users may not issue. This very necessary arrangement produces a problem of equipment availability for those who wish to develop or investigate operating systems programs, because such programs cannot be run as normal user jobs under an executive program. This thesis describes SIM360, a detailed simulator of the representative IBM S/360 computer, which was written to run student programs, programs assigned as machine problems for a course in operating systems. The simulator allows programs to issue all of the priveleged instructions of the S/360, and thus provides a readily available tool for the study of operating systems programs.

The Emptiness Problem for Automata on Infinite Trees

2023-03-30T03:58:36Z
The Emptiness Problem for Automata on Infinite Trees Hossley, Robert; Rackoff, Charles The purpose of this paper is to give an alternative proof to the decidability of the emptiness problem for tree automata, as shown in Rabin [4]. The proof reduces the emptiness problem for automata on infinite trees to that for automata on finite trees, by showing that any automata definable set of infinite trees must contain a finitely-genarable trees.

Construction Heuristics for Geometry and a Vector Algebra Representation of Geometry

2023-03-30T04:20:35Z
Construction Heuristics for Geometry and a Vector Algebra Representation of Geometry Wong, Richard Heuristics for generating constructions to help solve high school geometry problems are given. Many examples of the use of these heuristics are given. A method of translating geometry problems into vector algebra problems is discussed. The solution of these vector algebra geometry problems is analyzed. The use of algebraic constructions to help solve these vector problems is also discussed.

Economy of Descriptions and Minimal Indices

2023-03-30T03:05:54Z
Economy of Descriptions and Minimal Indices Bagchi, Amitava

Helping People Think

2023-03-30T03:12:43Z
Helping People Think Goldstein, Robert C. Everyone, today, is familiar with the use of machines to ease physical burdens. Since the dawn of civilization, man's progress in gaining control over his environment has been largely determined by the power and sophistication of the machines that he has been able to command. Furthermore, since simple machines can be used to construct more complicated ones, this process, once begun, tends to advance at an accelerating rate.

The Macaims Data Management System

2023-03-30T04:17:03Z
The Macaims Data Management System Goldstein, Robert C.; Strnad, Alois J. MacAIMS (MAC Advanced Interactive Management System) is a relatively small research project that was initiated in the summer of 1968 to investigate the feasibility of using some of the then existing computer facilities at M.I.T. to aid in the management of Project MAC. Several interesting and useful interactive programs were developed and are currently in use.

The Relational Approach to the Management of Data Bases

2023-03-30T03:54:04Z
The Relational Approach to the Management of Data Bases Strnad, Alois J. The ultimate goal of Project MacAIMS (MAC Advanced Interactive Management System) is to build a computer facility which will be able to support non-trivial decision making processes. (See reference 4). In the early stages of our experiments we discovered that traditional approaches to the management of data bases do not satisfy our needs. We have determined the following requirements for the management of Large Data Bases (LDB) in a dynamically varying environment such as an interactive Management Information System.

Transmission of Information Between a Man-machine Decision System and its Environment

2023-03-30T03:55:21Z
Transmission of Information Between a Man-machine Decision System and its Environment Wells, Douglas M.

The Substantive Use of Computers for Intellectual Activities

2023-03-30T03:15:48Z
The Substantive Use of Computers for Intellectual Activities Goldstein, Robert C.

A Computer Model of Simple Forms of Learning

2023-03-30T03:30:33Z
A Computer Model of Simple Forms of Learning Jones, Thomas L.

A New List-tracing Algorithm

2023-04-06T18:02:47Z
A New List-tracing Algorithm Fenichel, Robert R. List-processing systems have each allowed use of only a single size and configuration of list cell. This paper describes a system which allows use of arbitrarily many different sizes and configurations of list cell, possibly not specified until run time.

Automatic Code-generation from an Object-machine Description

2023-03-30T04:12:58Z
Automatic Code-generation from an Object-machine Description Miller, Perry L. This memo outlines the basic elements of a macro code-generating system, and develops an informal machine-independent model of a code generator. Then the memo discusses how an implementation of this model could be set up to generate code for a particular machine from machine-dependent information given in descriptive form.

Complexity Measures for Programming Languages

2023-03-30T03:08:48Z
Complexity Measures for Programming Languages Goodman, Leonard I. A theory of complexity is developed for algorithms implemented in typical programming languages. The complexity of a measuring a specific type of complexity is a complexity measure -- some function of the amount of a particular resource used by a program in processing an input. Typical resources would be execution time, core, I/O devices, and channels

Pseudo-random Sequences

2023-03-30T03:44:59Z
Pseudo-random Sequences Bruere-Dawson, Gerard The purpose of this paper is to study some notions of randomnes for infinite sequences of 0's and 1's.

An Expansion of the Data Structuring Capabilities of PAL

2023-03-30T03:28:31Z
An Expansion of the Data Structuring Capabilities of PAL Zilles, Stephen N.

Suspension of Processes in a Multiprocessing Computer System

2023-03-30T03:57:42Z
Suspension of Processes in a Multiprocessing Computer System Vogt, Carla M.

Use of High Level Languages for Sytems Programming

2023-03-30T04:22:21Z
Use of High Level Languages for Sytems Programming Graham, Robert M. (This paper is a slightly edited version of a transcript so that it still contains the colloquial flavor of the oral presentation.) I'm going to talk about languages for systems programming what they can do for us, and what we might expect from them in the future. These comments are largely based on my experience with the Multics System and I'll quote a few figures from Multics as we go along. I'm concerned particularly with large complex system.

File Management and Related Topics, June 12, 1970

2023-03-30T04:15:22Z
File Management and Related Topics, June 12, 1970 Graham, Robert M. The subject of these notes is file management. We will develop the problems of file management within the environment of a large information and computing service, often called a computer utility or general purpose time-sharing system. We do this for two reasons. First, this environment imposes the most severe constraints. Other environments are obtained by relaxing these constraints. Secondly, large information and computing services will become more prevalent in the years to come. Let us first look briefly at those objectives of an information and computing service which are significant to this discussion.

Description and Flow Chart of the PDP-7/9 Communications Package

2023-03-30T04:09:00Z
Description and Flow Chart of the PDP-7/9 Communications Package Ward, Philip W. The PDP-7/9 Communications Package was written to provide data transfers between the buffer controller (PDP-7 or PDP-9) of an ESL Display Console and a host computer via a 50-kilobit serial Dataphone link. Initially, only one of the displays (with a PDP-9 buffer controller) was to be operated remotely over q 50-kilobit line, and the only feasible access to the 7094 CTSS host computer was via the PDP-7 buffer controller of the other display, which is directly connected to CTSS channel D. For this connection, the PDP-7 could be looked upon as the "host" for the PDP-9, although it merely served as a message-handling intermediary for the real host, the 7094

Interactive Design Coordination for the Building Industry

2023-03-30T04:06:01Z
Interactive Design Coordination for the Building Industry Jackson, James N. The problem of effective communication in the process of building design and construction is widely recognized. The involvement of several design disciplines combined with the tendency for designers to work in distinct offices results in little capacity for them to investigate the influence of their design decisions on other design areas. One of the responses to the need for effective Interaction in the use of computers for design project is the supersytem concept proposed for ICES, the Integrated Civil Engineering System. The supersystem is defined as the cooperative effort on the part of the designers of several problem oriented computer capabilities to implement project capabilities by allowing each of their problem oriented subsystem to reference a single file of project data. The supersystem would allow design interaction by having each of the problem oriented computer subsystem reference a single file of information specifying the project. Future work in the application of computers to interactive and project oriented design in the building industry will have to concentrate on the file structure to be used in the Implementation of a computer building design supersystem.