ppxscal/embedding_network huggingface dataset:
UNIX security in a supercomputing environment
Authors: M. Bishop
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

The UNIX@@@@ operating system is designed for collaborative work and not for security. Vendors have modified this operating system (in some cases, radically) to provide levels of security acceptable to their customers, but the versions used in supercomputing environments would benefit from enhancements present in so-called secure versions. This paper discusses the need for security in a supercomputing environment and suggests modifications to the UNIX operating system that would decrease the vulnerability of those sites to attacks. Among the issues are additional auditing controls, changes to network programs, improved user authentication, and better application of the principle of least privilege.
The object-oriented integration methodology of the Cadlab work station design environment
Authors: J. Miller, K. Groning, G. Schulz, C. White
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

The Cadlab Work Station Design Environment is an integrated CAD environment. Like other integrated CAD environments, it consists of a single design management sub-environment and a set of application sub-environments integrated into a CAD framework. Unlike other integrated CAD environments, all of the components which combine to form the Cadlab Design Environment and the methodologies which are used to work with it are defined using a single object-oriented approach. By using an object-oriented approach, rapid integration, extension, and modification of the component sub-environments is possible. In this paper, the object-oriented Cadlab Design Environment is presented and the integration methodology is explained.
GRAMOL
Authors: C. Genillard, A. Strohmeier
Venue: ACM SIGPLAN Notices (1988)

A language for defining the lexical and syntactic grammars of languages is presented. The same notation is used for the two grammar descriptions. We will show that the language is unstratified, that is it can be used as its own metalanguage. Automatic generation of lexical analysers and syntactic parsers has been achieved by means of Ada packages.
HARTOS: a distributed real-time operating system
Authors: D. D. Kandlur, D. L. Kiskis, K. G. Shin
Venue: ACM SIGOPS Operating Systems Review (1989)

This paper outlines the design objectives and research goals for HARTOS, a distributed real-time operating system being developed at The University of Michigan. This effort is part of a larger research project to design and implement an experimental distributed real-time system called the Hexagonal Architecture for Real-Time Systems (HARTS). An important feature of HARTS is the use of an intelligent network processor to handle many of the functions relating to communications. The paper focuses on the communications aspects of the operating system and the control software kernel of the network processor. The preliminary version of the kernel provides good support for inter-process communication and distributed control. Its performance has been measured and analyzed and found to be comparable to that of other message passing systems like the V system.
Structured asynchronous communication routines for the FPS T-series
Authors: B. R. Carlile, D. Miles
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

An innovative programming environment for distributed computing has been developed for the new FPS T Series Parallel Vector Supercomputer. This programming model provides structured asynchronous communication routines, dynamic configuration of processing nodes into application topologies, and external data partitioning and distribution. The asynchronous communication routines have been written to enhance the inter-processor communication capabilities of the T Series. These routines span a wide cross-section of the structured communications necessary for distributed memory scientific computer applications. This includes nearest-neighbor communication, as well as data broadcast, data collection, and data rotation within a logical topology. There is also a routine which enables the user to specify custom communication patterns. Each routine is invoked by a single FORTRAN or C call to perform asynchronous communication in parallel with computation. The implementations of the communication routines use buffering, load balancing, and pipelining techniques. These routines allow one to quickly code high level parallel programs that are efficient as well as readable.
A General Constructive Approach to Fault-Tolerant Design Using Redundancy
Authors: A. E. Barbour, A. S. Wojcik
Venue: IEEE Transactions on Computers (1989)

The use of redundancy to attain a fault-tolerant system design is described. Specifically, a general theory of redundancy is proposed that allows the design of fault-tolerant structures at the system-level, gate-level, or both. The theory accounts for classic approaches to redundant design such as TMR, NMR, and quadded and interwoven logics. It is shown that, by using mathematical block theory, it is possible to describe complex interconnections of redundant elements in a simple, straightforward fashion. Comparisons are made with other approaches to redundant design.
Experience with topaz telebugging
Authors: David D. Redell
Venue: Proceedings of the 1988 ACM SIGPLAN and SIGOPS workshop on Parallel and distributed debugging (1988)

The Topaz TeleDebug (TTD) facility provides a remote debugging capability supporting software development in the Topaz environment. Topaz is a software environment providing rich support for programming in Modula2+, and extended version of Modula 2. TTD allows uniform use of the same high level source language debugger for all debugging (both local and remote) of software at all levels of the system. Special care has been taken to maximize TTD's reliability and robustness. Our experience suggests that such a facility can be extremely useful, very dependable and quite inexpensive. It also suggests that the implementation issues can be somewhat subtle, and that correct choices in this area are vital if the promise of such a scheme is to be fully realized. This paper focuses on those implementation issues in a fair amount of detail, analyzing the limitations of our first TTD implementation and the redesign that produced a second, improved version. Our main conclusion is that the target (debuggee) end of such a facility should be implemented at the lowest possible level in the operating system, and that a uniformly applicable remote invocation (e.g. remote procedure call) facility is key to enabling this approach. We also conclude that strict adherence to layered information hiding can lead to serious difficulties in the implementation of a remote debugging protocol. The discussion should be of particular interest to others designers of remote debugging facilities. While the paper does not devote much attention to higher level issues (e.g. novel user interfaces for debugging concurrent or distributed programs) most of the ideas discussed should be applicable to a wide class of debuggers, including those with higher aspirations for debugging such programs.
Can dataflow subsume von Neumann computing?
Authors: R. S. Nikhil
Venue: ACM SIGARCH Computer Architecture News (1989)

We explore the question: &ldquo;What can a von Neumann processor borrow from dataflow to make it more suitable for a multiprocessor?&rdquo; Starting with a simple, &ldquo;RISC-like&rdquo; instruction set, we show how to change the underlying processor organization to make it multithreaded. Then, we extend it with three instructions that give it a fine-grained, dataflow capability. We call the result P-RISC, for &ldquo;Parallel RISC.&rdquo; Finally, we discuss memory support for such multiprocessors. We compare our approach to existing MIMD machines and to other dataflow machines.
Optimizing horizontal microprograms for vectorial loops with timed petri nets
Authors: C. Hanen
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

This paper deals with the minimization of the asymptotic latency of horizontal microprograms performing vectorial loops. On a quite general architecture model, we show that all the constraints can be formalized to give a cyclic scheduling problem, modelled with a Timed Petri net. To analyse the net behaviour, a bivalued resolution graph is build. A critical cycle of this graph leads to optimal microprograms whose structure is independent on the number of iterations. This approach is then extended to uniform recurrences.
Duality in specification languages: a lattice-theoretical approach
Authors: R. J. R. Back, J. von Wright
Venue: Acta Informatica (1990)

A very general lattice-based language of commands, based on the primitive operations of substitution and test for equality, is constructed. This base language permits unbounded nondeterminism, demonic and angelic nondeterminism. A dual language permitting miracles is constructed. Combining these two languages yields an extended base language which is complete, in the sense that all monotonic predicate transformers can be constructed in it. The extended base language provides a unifying framework for various specification languages; we show how two Dijkstra-style specification languages can be embedded in it. &mdash;Authors' Abstract
The powerset algebra as a result of adding programming constructs to the nested relational algebra
Authors: Marc Gyssens, Dirk van Gucht
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

In this paper, we discuss augmentations of the nested relational algebra with programming constructs, such as while-loops and for-loops. We show that the algebras obtained in this way are equivalent to a slight extension of the powerset algebra, thus emphasizing both the strength and the naturalness of the powerset algebra as a tool to manipulate nested relations, and, at the same time, indicating more direct ways to implement this algebra.
Ada on hypercube
Authors: R. M. Clapp, T. Mudge
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

The widespread use of parallel machines, and hypercubes in particular, is being held back by the lack of high-order parallel programming languages. In this paper we discuss the issues involved in establishing an existing language that supports parallel processing, that is to say Ada, on a hypercube multiprocessor. An overview of the language is given, but the majority of the paper addresses the requirements and implementation of the run-time system, which is the key to establishing any parallel language. First, the requirements of the run-time system for Ada are described from a machine-independent point of view. Next, the approach taken toward implementing this system on a hypercube is discussed, with considerations given for language level program partitioning and interprocessor communication performance. Finally, the status of our current implementation is discussed and some concluding remarks are made about parallel languages in general, based on our experiences.
The design of phone-based interfaces for consumers
Authors: R. Halstead-Nussloch
Venue: ACM SIGCHI Bulletin (1989)

This paper identifies guidelines for designing human-computer interfaces using telephones as terminals. Although they are ubiquitous and convenient to use, phones differ from screen terminals in two important ways: the information display is auditory and serial, and users do not have a pointer. The differences result in limitations for the interface designer. The guidelines focus on developing an effective interface within the limitations. Ongoing analysis, design, development, and testing work at IBM Poughkeepsie and literature are synthesized into guidelines. They present design options for user input, system output, and the system and user roles in a phone-based dialogue.
Computer center stress test
Authors: Sue Stager
Venue: ACM SIGUCCS Newsletter (1988)

It's old news that the work environments of college and university computing centers are stressful. I put together the "Computer Center Stress Test" as a way to humorously deal with the day to day stress, and to maybe provoke some discussion about why some of these seemingly trivial and predictable events are stressful and what can be done to minimize the stress of these events in our environment.
IMPULSE: a high performance processing unit for multiprocessors for scientific calculation
Authors: T. Boku, S. Nomura, H. Amano
Venue: Proceedings of the 15th Annual International Symposium on Computer architecture (1988)

In this paper, we propose a high performance processing unit for multiprocessor systems for scientific calculations. This processing unit is called IMPULSE. IMPULSE is equipped with a hardware process control mechanism, and a powerful floating point processor and its controller. The process control method is based on the concurrent process model called the NC model. In the NC model, the processes and their communicating channels are static, and it is relatively easy to implement the interprocess communication server and process scheduler in hardware according to this model. To enhance the system performance, IMPULSE is composed of three parts, the TASK ENGINE, IPC ENGINE, and FPP ENGINE. From the results of simulations, it appears that the IPC ENGINE provides efficient process control even if the granularity of the processes is very fine.
A'UM = Stream + Object + Relation
Authors: K. Yoshiba, T. Chikayama
Venue: ACM SIGPLAN Notices (1989)

In this paper, we introduce a concurrent programming language A'UM [Yoshida88], which has been designed aiming at high parallelism and high expressivity for the development of large scale software. A'UM is characterized by three features: stream-based computation, object-oriented abstraction and relational representation.
Modeling, analysis, and optimal routing of flow-controlled communication networks
Authors: S. S. Lam, C.-T. Hsieh:0S2:0E
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

Closed queueing networks have been advocated by several authors to be a more desirable model than open queueing networks (Kleinrock's model) for network design. We compare open and closed network models and demonstrate the accuracy of a particular closed network model with experimental results. The proportional approximation method (PAM) is presented for evaluating performance measures of closed queueing networks. PAM algorithms have computational time and space requirements of O(KM), where M denotes the number of queues and K denotes the number of virtual channels in the network. Thus, PAM is the first (and only) method that can be used for solving industrial-strength network design problems using a closed network model. We formulate the following optimal routing problem: Find a route for a new virtual channel to be added to a network with existing flow-controlled virtual channels. A fast heuristic algorithm is presented. The algorithm uses PAM and exploits the following empirical observation: The route that maximizes the individual throughput of a virtual channel coincides in most cases with the route that maximizes the total network throughput (this is not true in general). We present statistical results from studies of 100 randomly generated networks to demonstrate the accuracy of PAM algorithms and the effectiveness of the optimal routing algorithm. (Exact solutions obtained by the tree convolution algorithm were used as benchmarks in our statistical studies.)
Generalization of the language version determination problem
Authors: K. C. Wong
Venue: ACM SIGART Bulletin (1990)

In this paper, we generalize the language version determination problem by relaxing the assumption of version subset relationship. The search algorithms proposed for the generalized problem involve constant search time using a hash table to implement the search for language versions. The hash table stores version features and their corresponding versions containing them. Maintaining the hash table is done by inserting newly developed versions in the version lists corresponding to those features newly added and those contained in the versions from which the new versions are developed, excluding the features being deleted.
Sparse matrix technology tools in APL
Authors: Ferdinand Hendriks, Wai-Mee Ching
Venue: ACM SIGAPL APL Quote Quad (1990)

We have implemented sparse matrix technology tools in APL. Such tools have been conspicuously scarce, because APL has not been the language of choice for solving boundary value problems governed by partial differential equations. But when carefully coded, APL is able to tackle problems governed by partial differential equations in a way that ads flexibility and, on account of its compactness, maintainability. The main criticism of APL in numerically intensive applications has been execution speed. APL compilation addresses this drawback and shows factors of speed improvement of better than about three. Timings will be presented for some benchmark elliptical boundary value problems, both for interpretive and compiled APL. Examples are given of common tasks that are encountered in conjunction with the finite element method, such as determination of the symbolic form of the stiffness matrix, and the more universal task of solution of a sparse (symmetric) set of equations using the conjugate gradient method.
Performance analysis of multipath multistage interconnection networks
Authors: S. C. Kothari, A. Jhunjhunwala, A. Mukherjee
Venue: Proceedings of the 1988 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1988)

This paper closely examines the performance analysis for unbuffered multipath multistage interconnection networks. A critical discussion of commonly used analysis is provided to identify a basic flaw in the model. A new analysis based on the grouping of alternate links is proposed as an alternative to rectify the error. The results based on the new analysis and extensive simulation are presented for three representative networks. The simulation study strongly supports the results of the new analysis.
Trade-offs between devices and paths in achieving disk interleaving
Authors: S. Ng, D. Lang, R. Selinger
Venue: ACM SIGARCH Computer Architecture News (1988)

There is a continuing need to improve the performance of disk subsystems, and one of the key factors of a disk subsystem's performance is the data transfer rate. While it is clear that increasing the data transfer rate would reduce the service time for those applications that move large amounts of data per I/O, the amount of data transferred per I/O in many of today's typical commercial applications is relatively small. The benefit of a higher data rate in these environments was not well understood, but is explored here and is found to be larger than expected. One way to increase the data rate of the disk subsystem is through a technique generally known as striping. Using this approach, multiple conventional disks are grouped together and function as if they were a single one, with the data spread among the multiple disks and transferred in parallel. In this paper, we study four alternative implementations for achieving higher data rates in a disk subsystem, focusing on the trade-offs between the number of devices and the number of data paths, keeping the number of physical devices constant (which may keep the cost roughly constant). The performance advantages and limitations of the alternative implementations are analyzed using an analytic queuing model and compared to a conventional disk subsystem.
Using Prolog to present abstract machines
Authors: D. Crookes
Venue: ACM SIGCSE Bulletin (1988)

Introductory courses in Theory of Computation usually include a study of abstract machines such as finite state machines and Turing machines. This paper demonstrates that a neat and useful way of presenting these automata is to use a logic programming language such as Prolog, making the approach useful from a teaching point of view. Not only does a Prolog specification provide a precise definition of an automoton's behaviour, but it also gives an immediately-executable simulator. The reversible execution property of Prolog programs can make these simulators inherently more powerful than traditional simulators. The paper includes Prolog specifications for finite state machines, Turing machines, linear bounded automata, and pushdown automata.
A data model and query language for EXODUS
Authors: Michael J. Carey, David J. DeWitt
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

In this paper, we present the design of the EXTRA data model and the EXCESS query language for the EXODUS extensible database system. The EXTRA data model includes support for complex objects with shared subobjects, a novel mix of object- and value-oriented semantics for data, support for persistent objects of any type in the EXTRA type lattice, and user-defined abstract data types (ADTs). The EXCESS query language provides facilities for querying and updating complex object structures, and it can be extended through the addition of ADT functions and operators, procedures and functions for manipulating EXTRA schema types, and generic set functions EXTRA and EXCESS are intended to serve as a test vehicle for tools developed under the EXODUS extensible database system project.
An execution model for distributed object-oriented computation
Authors: Edward H. Bensley, Thomas J. Brando, Myra Jean Prelle
Venue: ACM SIGPLAN Notices (1988)

This paper describes an execution model being developed for distributed object-oriented in a message-passing multiple-instruction/multiple-data-stream (MIMD) environment. The objective is to execute an object-oriented program as concurrently as possible. Some opportunities for concurrency can be identified explicitly by the programmer. Others can be identified at compile time. There are some opportunities for concurrency, however, that can only be discovered at runtime because they are data-dependent. The model of execution we describe attempts to discover and exploit the data-dependent concurrency that exists in a given program execution.
Object Oriented Programming
Authors: B. P. Pokkunuri
Venue: ACM SIGPLAN Notices (1989)

Object Oriented Programming (OOP) is being used quite widely in the fields of both software engineering and artificial intelligence. The aim of this article is to give an idea of OOP and its features. It includes an indication of the available OOP environments and the Object-Oriented extensions made to the conventional languages such as C and Pascal. Some of the advantages in the use of OOP are also described briefly.
The proposal of a computing model for prototypes of microprogrammed machines solving complex problems
Authors: E. Binaghi, G. Pasi, G. R. Sechi
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

Our research work concerns the definition of computational systems for the solution of complex scientific problems. In this work we present the analysis of a computing model for the definition and the implementation of microprogrammed prototypal machines. The computing model is expressed in terms of a system of equations. The structure and the control of a microprogrammed machine is directly implied by the formally defined properties of the system of equations.