ppxscal/embedding_network huggingface dataset:
Stochastic Petri Net Representation of Discrete Event Simulations
Authors: P. J. Haas, G. S. Shedler
Venue: IEEE Transactions on Software Engineering (1989)

In the context of discrete event simulation, the marking of a stochastic Petri net (SPN) corresponds to the state of the underlying stochastic process of the simulation and the firing of a transition corresponds to the occurrence of an event. A study is made of the modeling power of SPNs with timed and immediate transitions, showing that such Petri nets provide a general framework for simulation. The principle result is that for any (finite or) countable state GSMP (generalized semi-Markov process) there exists an SPN having a marking process that mimics the GSMP in the sense that the two processes (and their underlying general state-space Markov chains) have the same finite dimensional distributions.
A new responsive distributed shortest-path rounting algorithm
Authors: B. Rajagopalan, M. Fairman
Venue: Symposium proceedings on Communications architectures protocols (1989)

Distributed shortest-path routing algorithms based on the Ford-Fulkerson method are simple to implement but they suffer from the cost-dependent looping problem: when link costs increase, routing table loops may form and convergence to correct paths may be too slow, depending on link costs. This problem can be eliminated if constraints are imposed on the order in which routing tables are updated at different nodes but the resulting internode protocols tend to be relatively complex. Furthermore, update constraints may restrict a node's ability to obtain alternate paths quickly in an environment where topology changes are frequent. In this paper, a new distributed shortest-path routing scheme based on the Ford-Fulkerson method is presented. Under the new scheme, each node uses partial topology information to eliminate the cost-dependent looping problem. No update constraints are imposed and no assumptions are made regarding link costs. In the worst case, the new scheme responds to link cost changes in O(D) update steps, where D is the diameter of the network after the occurrence of the changes.
The design of nectar: a network backplane for heterogeneous multicomputers
Authors: Emmanuel Arnould, H. T. Kung, Francois Bitz, Robert D. Sansom, Eric C. Cooperm
Venue: ACM SIGARCH Computer Architecture News (1989)

Nectar is a &ldquo;network backplane&rdquo; for use in heterogeneous multicomputers. The initial system consists of a star-shaped fiber-optic network with an aggregate bandwidth of 1.6 gigabits/second and a switching latency of 700 nanoseconds. The system can be scaled up by connecting hundreds of these networks together. The Nectar architecture provides a flexible way to handle heterogeneity and task-level parallelism. A wide variety of machines can be connected as Nectar nodes and the Nectar system software allows applications to communicate at a high level. Protocol processing is off-loaded to powerful communication processors so that nodes do not have to support a suite of network protocols. We have designed and built a prototype Nectar system that has been operational since November 1988. This paper presents the motivation and goals for Nectar and describes its hardware and software. The presentation emphasizes how the goals influenced the design decisions and led to the novel aspects of Nectar.
Concurrency in heavily loaded neighborhood-constrained systems
Authors: Valmir C. Barbosa, Eli Gafni
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1989)

Let G be a connected undirected graph in which each node corresponds to a process and two nodes are connected by an edge if the corresponding processes share a resource. We consider distributed computations in which processes are constantly demanding all of their resources in order to operate, and in which neighboring processes may not operate concurrently. We advocate that such a system is general enough for representing a large class of resource-sharing systems under heavy load. We employ a distributed scheduling mechanism based on acyclic orientations of G and investigate the amount of concurrency that it provides. We show that this concurrency is given by a number akin to G's chromatic and multichromatic numbers, and that, among scheduling schemes which require neighbors in G to alternate in their turns to operate, ours is the one that potentially provides the greatest concurrency. However, we also show that the decision problem corresponding to optimizing concurrency is NP-complete.
An overview of DOD-STD-1838A (proposed) the common APSE interface set: revision
Authors: Robert Munck, Patricia Oberndorf, Erhard Ploedereder, Richard Thall
Venue: Proceedings of the third ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1989)

A five-year effort under the Ada Joint Program Office has developed a proposed standard for a host system interface as seen by tools running in an Ada Programming Support Environment (APSE). Standardization of this interface as DOD-STD-1838A will have a number of desirable effects for the Department of Defense, including tool portability, tool integration, data transportability, encouragement of a market in portable tools, and better programmer productivity. As the capability of tools to communicate with each other is a central requirement in APSEs, the Common APSE Interface Set (CAIS) has paid particular attention to facilitate such communication in a host-independent fashion. CAIS incorporates a well-integrated set of concepts tuned to the needs of writers and users of integrated tool sets. This paper covers several of these concepts: &bull; the entity management system used in place of a traditional filing system, &bull; object typing with inheritance, &bull; process control including atomic transactions, &bull; access control and security, &bull; input/output methods, &bull; support for distributed resource control, and &bull; facilities for inter-system data transport.
Data replicas in distributed information services
Authors: H. M. Gladney
Venue: ACM Transactions on Database Systems (TODS) (1989)

In an information distribution network in which records are repeatedly read, it is cost-effective to keep read-only copies in work locations. This paper presents a method of updating replicas that need not be immediately synchronized with the source data or with each other. The method allows an arbitrary mapping from source records to replica records. It is fail-safe, maximizes workstation autonomy, and is well suited to a network with slow, unreliable, and/or expensive communications links. The algorithm is a manipulation of queries, which are represented as short encodings. When a response is generated, we record which portion of the source database was used. Later, when the source data are updated, this information is used to identify obsolete replicas. For each workstation, the identity of obsolete replicas is saved until a workstation process asks for this information. This workstation process deletes each obsolete replica, and replaces it by an up-to-date version either promptly or the next time the application asks for this particular item. Throughout, queries are grouped so that the impact of each source update transaction takes effect atomically at each workstation. Optimizations of the basic algorithm are outlined. These overlap change dissemination with user service, allow the mechanism to be hidden within the data delivery subsystem, and permit very large networks.
Continuous extensions of Rosenbrock-type methods
Authors: Alexander Ostermann
Venue: Computing (1990)

Solving an initial value problem by a Rosenbrock method produces, in general, the numerical solution at (in advance unknown) gridpoints. Applications requiring frequent output (as graphics, delay differential equations, problems with driving equations) normally restrict the stepsize control of these codes and increase the computational overhead considerably. In this paper we introduce a class of continuous extensions for Rosenbrock-type methods. These extensions furnish a continuous numerical solution without affecting the efficiency of the codes. &mdash;Author's Abstract
Comments on 'Axiomatizing Software Test Data Adequacy' by E.J. Weyuker
Authors: S. H. Z. Zweben, J. S. Gourlay
Venue: IEEE Transactions on Software Engineering (1989)

E.J. Weyuker recently proposed a set of properties which should be satisfied by any reasonable criterion used to claim that a computer program has been adequately tested. The author called these properties 'axioms'. She also evaluated several well-known testing strategies with respect to these properties, and concluded that some of the commonly used strategies failed to satisfy several of the properties. The commenters question both the fundamental nature of the properties and the precision with which they are presented, and illustrate how a number of ideas in E.J. Weyuker's paper can be simplified and clarified through greater precision and a more consistent set of definitions. They also reanalyze the testing strategies after accounting for these inconsistencies. The strategies tend to work better as a result of this reanalysis. The author rebuts the commenter's arguments.
Application programming as the construction of language interpreters
Authors: R. A. Frost
Venue: ACM SIGPLAN Notices (1989)

Application programming is often carried out in an ad hoc way compared to the construction of code for implementing operations in 'standard calculi' such as relational calculus, number theory, set theory, etc. The various programming techniques, such as 'abstraction' and 'transformation', which are often used in the latter are infrequently used in application programming. We believe that more structured approaches to application programming may facilitate the use of established programming techniques in application programming. In this paper, we explore one such approach that is based on the notion of 'application programming as the construction of language interpreters'. We have built a 'system' to support this approach. The system that we have built consists of a number of higher order functions that can be used to 'glue together' parts of a specification of an attribute grammar such that the result is an executable interpreter. These functions facilitate the 'language processing' part of application programming. Our implementation language is a higher order, lazy, pure functional programming language; this facilitates the 'standard calculi' part of application programming. We claim that for certain types of application programming, our system not only helps the programmer to separate these two aspects of the problem, but that it also provides a framework in which both aspects can be addressed methodically, taking advantage of various programming techniques such as 'abstraction' and 'transformation', and subsequently re-integrated to obtain the required program. We have extended the basic notion of attribute grammars so that our approach has wider application. The extension is based upon a new notion of 'multi-input parsing'.
Distributed artificial intelligence: a necessary paradigm for supervising production management activities
Authors: Jean Pierre Laurent, Agnes Lanusse, Bernard Pierre Panet
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

Each unit-controller is a knowledge-based system, built on top of a blackboard mechanism. Indeed, each unit-controller must react to about the state of its internal activities as well asq to arrivals of messages sent by other unit-controllers. The blackboard mechanism allows the unit-controller to take such events into account in an opportunistic way and in real-time.A set of knowledge sources describes the possible behaviours of the unit-controller toward the possible situations. The action of the knowledge sources can be: to start specific internal activities, to send messages to other unit-controllers, or to create new events on the blackboard (i.e. modification of the internal situation).Each unit-controller uses two kinds of knowledge : specific knowledge about the island it is in charge of, and more generic knowledge about supervision tasks in general (internal and external). This generic knowledge about supervision tasks (internal and external) is used to guide the basic functionning of the blackboard mechanism while specific behavioural knowledge-bases help it to react correctly to events relative to its internal activities or to messages sent by other unit-controllers.Because, a large part of the knowledge which is used by a unit-controller is generic, we have build a unit-controller shell. Each unit-controller is thus obtained by instantiation of this unit-controller shell and by addition of specific informations about a specific island.Finally, in the system outcoming from the ESPRIT 932 Project, the task of supervising the Production Management activities is performed by a set of knowledge-based systems using blackboard mechanisms for cooperating with each other and this actually makes it a typical DAI system.
Building interfaces interactively
Authors: David N. Smith
Venue: Proceedings of the 1st annual ACM SIGGRAPH symposium on User Interface Software (1988)

The Interface Construction Set (InterCONS) is a visual language and environment. It consists of: a data flow language; an editor for building and testing data flow programs, and for making presentation views of the programs; libraries for holding completed programs; and a presentation system for interacting with finished programs and sequences of programs. This paper describes how interfaces are built using the data flow language. A companion paper describes the data flow language and its primitives for arithmetic, logic, interactive control, path control, visual output, and program control; the execution model is also described. InterCONS is useful for experimenting with new kinds of interactive controls, and building models of interactive applications.
Efficient algorithms for extracting the K most critical paths in timing analysis
Authors: S. H. Yen, D. H. Du, S. Ghanta
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

Path extracting algorithms are a very important part of timing analysis approach. In this paper we designed and developed several algorithms which can generate the K most critical paths in a non-increasing order of their delays. The effectiveness of these algorithms is shown by some experimental results.
Analysis of euclidean algorithms for polynomials over finite fields
Authors: Keju Ma, Joachim von zur Gathen
Venue: Journal of Symbolic Computation (1990)

This paper analyzes the Euclidean algorithm and some variants of it for computingthe greatest common divisor of two univariate polynomials over a finite field. The minimum, maximum and average number of arithmetic operations both on polynomials and in the ground field are derived. We consider five different algorithms to compute gcd(A"1, A"2) where A"1, A"2@?Z"2[x] have degrees m>=n>=0. Compared with the classical Euclidean algorithm that needs on average 1/2n+1 polynomial divisions, two algorithms involving divisions need on average 1/3n+O(1) and 1/4n+O(1) polynomial divisions; two other algorithms use an average of 1/2m+1/3n+O(1) and 1/4m+2/9n+O(1) polynomial substractions and no divisions.
Intelligent information retrieval with proto-Gnosis
Authors: Winfried Boeing
Venue: ACM SIGBIO Newsletter (1987)

This paper describes first experiences with the language proto-GNOSIS, a hybrid of MUMPS and PROLOG. The objective of the GNOSIS project is to create a GNOSIS shell, specified as a superset of X/OPEN capabilities. The shell will also be used at the University of Cologne to develop an intelligent information retrieval (IIR) system. This paper outlines an approach for IIR and illustrates the problem. Some mechanisms for an IIR system are discussed briefly. Then some examples from the GNOSIS language extensions are given.
VLSI leaf cell design by understanding circuit structures
Authors: W. Lue, L. D. McNamee
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

A new approach utilizing MOS circuit structures extracted from a circuit net-list for designing VLSI leaf cells is described. A circuit structure is explicitly present in a circuit schematic diagram on which a designer relies for drawing a layout. However, it is absent in the net-list input to an automatic layout system. In this paper, how to extract schematic like information from a net-list and how to apply it for automatic leaf cell design are discussed.
A comparison of four two-dimensional gate matrix layout tools
Authors: M. J. Irwin, R. M. Owens
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

A comparison of four layout tools is presented. The layout style is a two-dimensional gate matrix. The first layout tool discussed uses &ldquo;standard&rdquo; simulated annealing. Annealing on gate clusters instead of individual gates can be used to improve the layout results. Two different ways of determining good gate clusters for use in the annealing process are compared. The first way uses clusters derived from user specified gate hierarchies, while the second determines clusters based on gate connectivity. The fourth layout tool uses a decomposition scheme based on quadrisection. Layout results for a set of benchmark circuits are presented for each of the tools.
Partial order maintenance
Authors: C. Collin, R. Levinson
Venue: ACM SIGIR Forum (1989)

In this paper we show how to maintain a partially-ordered hierarchy of patterns by subpattern-of for efficient associative retrieval. The techniques described here are most applicable for databases of complex data structures such as graphs or matrices as opposed to simple data structures such as relations, sets, lists or frames that are seen in most information retrieval systems. Any representation scheme for the patterns in the database may be used as long as the user provides the system with the function that compares two patterns in the representation scheme and determines if one pattern is a subpattern of the other, if the patterns are identical or the patterns are incomparable. The user also provides utilities for reading and writing the patterns.
Practical parsing of generalized phrase structure grammars
Authors: Anthony J. Fisher
Venue: Computational Linguistics (1989)

An efficient algorithm is described for parsing a dialect of generalized phrase structure grammar (GPSG). A practical parsing system, based on the algorithm, is presented. The dialect of GPSG which the parsing system accepts is smaller, but considerably "purer" (closer to the original definition of GPSG) and mathematically "cleaner" than that which is accepted by other practical parsing systems. In particular, the parsing system correctly implements feature co-occurrence restrictions, subject only to the restriction that the FCR set can be expressed in clausal form as a set of Horn clauses.
Parallelizing a large scientific code - methods, issues, and concerns
Authors: E. A. Carmona
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

Objectives of this study were to develop techniques and methods for effective analysis of large codes; to determine the feasibility of parallelizing an existing large scientific code; and to estimate potential speedups attainable, and associated tradeoffs in design complexity and work effort, if the code were parallelized by redesign for a distributed memory system (NCube, iPSC hypercube), or straight serial translation targetting a shared memory system (CRAY2, SEQUENT). MACH2, the code under study, is a 2-D magnetohydrodynamic (MHD) finite difference code used to simulate plasma flow switches and nuclear radiation. A taxonomy relating functional levels of a code to levels of parallelism is presented and used as a model for analyzing existing large codes. It is shown that although parallelizing lower level code segments (e.g. algorithms and loops) on shared memory systems is generally easier to accomplish, in some cases an entire large code is most easily parallelized at a high level; via domain and functional decomposition. Also a multi-decomposition scheme is introduced in which acceptable load balances can be achieved for functional decompositions and heterogeneous data partitionings.
A nilpotent quotient algorithm for graded Lie rings
Authors: George Havas, M. F. Newman, M. R. Vaughan-Lee
Venue: Journal of Symbolic Computation (1990)

A nilpotent quotient algorithm for graded Lie rings of prime characteristic is described. Thealgorithm has been implemented and applications have been made to the investigation of the associated Lie rings of Burnside groups. New results about Lie rings and Burnside groups are presented. These include detailed information on groups of exponent 5 and 7 and their associated Lie rings.
Creating consistency in the user interface: opinions and procedures of software developments experts
Authors: A. L. Happ, K. C. Cohen
Venue: ACM SIGCHI Bulletin (1989)

The User Interface Technology department of IBM, Boca Raton, recently commissioned a study on the topic of consistency in the user interface. Of interest were general principles related to consistency, the methods of developing and/or attaining it in product development, and the relative effectiveness of IBM's Systems Application Architecture manual, Common User Access - Panel Design and Interaction (CUA V 1.0 1987), in helping independent software vendors achieve consistency in their products.
A heretical view on type embedding
Authors: R. T. Boute
Venue: ACM SIGPLAN Notices (1990)

Based on a useful concept of type-ordering that implicity or explicitly underlies the type of certain programming languages, it is shown that the type "boolean" can be viewed as a subtype of the type "natural" and hence, by transitivity, of "integer", "rational", and so on. This implies defining #120121; = {0, 1 } rather than B = {false, true}, and results in many useful mathematical properties that are not available with the latter definition. It is shown how the danger of confusion (which is often considerably overrated anyway) can be eliminated, and how a slight modification in the formulation of predicate logic can accommodate this definition rather conveniently. The theoretical and practical advantages are illustrated by means of examples.
Metamodels for system development
Authors: P. Kokol
Venue: ACM SIGSOFT Software Engineering Notes (1989)

Information management is critical in business and engineering applications. Many empirical studies indicates both technical and nontechnical problems with information systems which are briefly reviewed in this paper, together with possible causes and solutions. The formalization of the IS development process is described in more details. Some metamodels are presented next and explained on a case of the JSD methodology. A NEW metamodel which is a combination of existing ones is proposed at the end.
A comparison study of automatically vectorizing Fortran compilers
Authors: H. Nobayashi, C. Eoyang
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

The performance of current vector processing supercomputers is highly dependent on the capabilities of their automatically vectorizing Fortran compilers to generate efficient vector code. In this paper we shall focus on the performance of these compilers, and attempt to compare their efficiency on different types of Fortran loop constructs. Our analysis will involve a short analysis of previous compiler comparison studies and we will introduce a new technique for evaluating and comparing compiler performance.