ppxscal/embedding_network huggingface dataset:
Hypercube message routing in the presence of faults
Authors: Jesse M. Gordon, Quentin F. Stout
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

We discuss the problem of routing messages on hypercubes which have faulty processors and/or communication links. We are motivated by the belief that simple algorithms, operating under simple assumptions, can ensure high probabilities of successful message routing. In this paper, we consider the basic problem of routing a single message from an arbitrary source to an arbitrary destination. In our study, a fault is assumed to render the processor or link non-functional for purposes of communicating messages. As such, we may also consider communications hot spots as node faults, and our results also apply to routing in congested hypercubes. A framework for the analysis of fault tolerant routing schemes on a hypercube is presented. This framework includes differing routing schemes, routing information models and fault distribution models. The a priori probabilities of successful routing of a single, indivisible message under each of our possible sets of assumptions are calculated. Using random routing, under the one-step local information routing model, we show that the a priori probability of successful message routing is high even for an exceedingly large number of faults. We also analyze the behavior of sidetracking, a routing method which combines the concepts of local information and randomization. Using sidetracking, and in the one-step local information routing model, a message will be routed forward using random routing. If the message reaches a blocked processor (no non-faulty neighbors along a minimal path to the destination) it will be sent to a non-faulty neighbor, chosen uniformly at random from the set of non-faulty neighbors. We use simulation experiments to determine the performance of this routing scheme, analyzing the probability of successful routing and the expected path length of a routed message. The empirical performance of the sidetracking algorithms indicates strongly that, in the limit as the cube dimension grows larger and for a fixed probability of node failure, the probability of successful message routing is 100%.
Data buffering: run-time versus compile-time support
Authors: H. Mulder
Venue: ACM SIGARCH Computer Architecture News (1989)

Data-dependency, branch, and memory-access penalties are main constraints on the performance of high-speed microprocessors. The memory-access penalties concern both penalties imposed by external memory (e.g. cache) or by under utilization of the local processor memory (e.g. registers). This paper focuses solely on methods of increasing the utilization of data memory, local to the processor (registers or register-oriented buffers). A utilization increase of local processor memory is possible by means of compile-time software, run-time hardware, or a combination of both. This paper looks at data buffers which perform solely because of the compile-time software (single register sets); those which operate mainly through hardware but with possible software assistance (multiple register sets); and those intended to operate transparently with main memory implying no software assistance whatsoever (stack buffers). This paper shows that hardware buffering schemes cannot replace compile-time effort, but at most can reduce the complexity of this effort. It shows the utility increase of applying register allocation for multiple register sets. The paper also shows a potential utility decrease inherent to stack buffers. The observation that a single register set, allocated by means of interprocedural allocation, performs competitively with both multiple register set and stack buffer emphasizes the significance of the conclusion
Using simulation to compile diagnostic rules from a manufacturing process representation
Authors: L. A. Becker, R. Barlett, F. Soroushian
Venue: Issue 108 (April 1989) (1989)

Instead of acquiring diagnostic rules about a manufacturing process directly from domain experts, one can acquire a deeper, model-based representation, and compile the diagnostic rules directly from it. A manufacturing process representation (MPR) is a deep (Harmon, 1985), functional representation (Davis, 1984; Chandrasekaran, 1985) which embodies a model of the given process. This representation includes knowledge about the ordering of process steps, as well as what they are designed to accomplish and what would make them fail or what errors they may trap. As indicated below, an MPR can be acquired either by a knowledge engineer (KE), who would interview an expert and make use of any available process design documents, or by an Intelligent Interrogator (II) program.
A Protocol Modeling and Verification Approach Based on a Specification Language and Petri Nets
Authors: Toshinori Suzuki, Sol M. Shatz, Tadao Murata
Venue: IEEE Transactions on Software Engineering (1990)

An approach for automated modeling and verification of communication protocols is presented. A language that specifies the input/output behavior of protocol entities is introduced as the starting point of the approach, and verification of the linguistic specifications is discussed. Rules for conversion of the specifications into a Petri net model (based on a timed Petri net) are presented and illustrated by examples. This leads to a second level of verification on the net model. The approach is illustrated by its application to a part of the LAPD protocol.
Type declarations as subtype constraints in logic programming
Authors: Dean Jacobs
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

This paper presents a type system for logic programs that supports parametric polymorphism and subtypes. This system follows most knowledge representation and object-oriented schemes in that subtyping is name-based, i.e., &tgr;1 is considered to be a subtype of &tgr;2 iff it is declared as such. We take this as a fundamental principle in the sense that type declarations have the form of subtype constraints. Types are assigned meaning by viewing such constraints as Horn clauses that, together with a few basic axioms, define a subtype predicate. This technique provides a (least) model for types and, at the same time, a sound and complete proof system for deriving subtypes. Using this proof system, we define well-typedness conditions which ensure that a logic program/query respects a set of predicate types. We prove that these conditions are consistent in the sense that every atom of every resolvent produced during the execution of a well-typed program is consistent with its type.
APL2-a RISC business
Authors: M. Alfonseca, D. Selby
Venue: ACM SIGAPL APL Quote Quad (1987)

APL2 is one of the most exciting programming languages to evolve from IBM's original APL discovery. APL2 has been restricted to IBM 370 mainframe computers, due to the complexity of the interpreter required to implement all facets of the language. This paper describes a joint research / feasibility study carried out by IBM's Madrid and Winchester Scientific Centres on generating a &ldquo;Portable&rdquo; Workstation APL2 interpreter.
Computing the irreducible real factors and components of an algebraicf curve
Authors: E. Kaltofen
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

We present algorithms that decompose an algebraic curve with rational coefficients in its defining bivariate equation into its irreducible real factors and its non-empty irreducible real components. We show that our algorithms are of polynomial bit complexity in the degree of the equation and the size of its coefficients. Our construction is based on computing the irreducible complex factors and then investigating high precision complex floating point coefficients of these factors and the complex norms.
Parallel algorithms for geometric searching problems
Authors: S.-J. Oh, M. Suk
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

Computational Geometry is concerned with the design and analysis of computational algorithms which solve geometry problems. In this paper SIMD-MCC algorithms for solving geometric searching problems such as the point domination, the point maxima, the range searching, and the closest point problems are designed by using the parallel divide-and-conquer technique. The computational complexities of all these algorithms for N input points in the k-dimensional space are O(CkN0.5), where Ck = (20.5 + 1)k-2.
Progress report on a system for general-purpose parallel symbolic algebraic computation
Authors: B. W. Char
Venue: Proceedings of the international symposium on Symbolic and algebraic computation (1990)

We discuss on-going work on large-grained parallel symbolic computation using a system based on Maple and Linda. The prototype runs on a Sequent Balance. The approach can be used with most existing algebra/symbol manipulation systems, and provides the potential to deliver of parallel symbolic computation on a variety of architectures (e.g. shared memory, hypercubes, networked workstations). Parallel speedup was achieved on a variety of algebraic problems, although many significant improvements in efficiency remain to be achieved.
The role of the video professional in a research environment
Authors: M. D. Chow
Venue: ACM SIGCHI Bulletin (1989)

The video professional that enters the research environment is likely to encounter both exhilarating resonances and boggling confusion at the hands of researchers. There will be situations when standard video practice exactly compliments the researchers' work. There will also be situations when it is necessary to break every rule held sacred by video practitioners. This paper is an attempt to outline some of the many ways in which the research scientist and the video professional can coexist productively. The focus will be on usage of video as a presentation tool.
Efficient algorithms for computing the longest viable path in a combinational network
Authors: P. C. McGeer, R. K. Brayton
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

We consider the elimination of false paths in combinational circuits. We give the single generic algorithm that is used to solve this problem, and demonstrate that it is parameterized by a Boolean function called the sensitization condition. We give two criteria which we argue that a valid sensitization condition must meet, and introduce four conditions that have appeared in the recent literature, of which two meet the criteria and two do not. We then introduce a dynamic programming procedure for the tightest of these conditions, the viability condition, and discuss the integration of all four sensitization conditions in the LLLAMA timing environment. We give results on the IWLS and ISCAS benchmark examples and on carry-bypass adders.
The Full-Use-of-Suitable-Spares (FUSS) Approach to Hardware Reconfiguration for Fault-Tolerant Processor Arrays
Authors: M. Chean, J. A. B. Fortes
Venue: IEEE Transactions on Computers (1990)

A general approach to hardware recognition is proposed for VLSI/WSI fault-tolerant processor arrays. The technique, called full use of suitable spares (FUSS), uses an indicator vector, the surplus vector, to guide the replacement of faulty processors within an array. Analytical study of the general FUSS algorithm shows that there is a linear relationship between the array size and the area of interconnect required for reconfiguration to be 100% successful. In an instance of FUSS, called simple FUSS, reconfiguration is done by shifting up to or down the surplus vector's entries. The surplus vector is progressively updated after each column is reconfigured. The reconfiguration is successful when the surplus vector becomes null. Simple FUSS is discussed in detail and evaluated. Simulations show that when the number of faulty processors is equal to that of space processors, simple FUSS can achieve a probability of survival as high as 99%.
A microprogrammed interpreter for concurrent euclid
Authors: K. Lall, J. W. Atwood
Venue: Proceedings of the 22nd annual workshop on Microprogramming and microarchitecture (1989)

There are several methods of executing programs written in a high level language. The most widely used is to compile the programs into machine language. Another is to translate the programs into some intermediate form and then to execute that form interpretively. A third method is to directly execute either the HLL or the intermediate form. This study was aimed at investigating the feasibility of directly executing the intermediate representation of the sequential features of Concurrent Euclid (CE) on the SEL 32/75 computer. The CE intermediate code was translated into Ecode, and a microprogrammed interpreter for Ecode was designed and implemented on the SEL, and benchmarked against the compiler. For the CPU-bound prime number algorithm Sieve of Eratosthenes, the interpreter was measured to be about twice as slow as the compiler, due primarily to poor overlap within microinstructions. Ecode was then modified, and a new translator and interpreter designed and implemented. The same benchmark then yielded comparable results for both the interpreter and compiler. We project that further changes in Ecode design and hardware support would result in substantial Ecode efficiency gains.
CAL: A theoretical background of constraint logic programming and its applications
Authors: Kô Sakai, Akira Aiba
Venue: Journal of Symbolic Computation (1989)

Constraint logic programming (CLP) is an extension of logic programming by introducing the facility of writing and solving constraints in a certain domain. CAL (Contrainte avec Logique) is a CLP language in which (possibly non-linear) polynomial equations can be written as constraints, while almost all the other CLP languages proposed so far have concentrated only on linear equations and inequations. This paper describes a general semantics of CLP including CAL, and shows the validity of CAL in this framework.
Decentralizing a global naming service for improved performance and fault tolerance
Authors: D. R. Cheriton, T. P. Mann
Venue: ACM Transactions on Computer Systems (TOCS) (1989)

Naming is an important aspect of distributed system design. A naming system allows users and programs to assign character-string names to objects, and subsequently use the names to refer to those objects. With the interconnection of clusters of computers by wide-area networks and internetworks, the domain over which naming systems must function is growing to encompass the entire world. In this paper we address the problem of a global naming system, proposing a three-level naming architecture that consists of global, administrational, and managerial naming mechanisms, each optimized to meet the performance, reliability, and security requirements at its own level. We focus in particular on a decentralized approach to the lower levels, in which naming is handled directly by the managers of the named objects. Client-name caching and multicast are exploited to implement name mapping with almost optimum performance and fault tolerance. We also show how the naming system can be made secure. Our conclusions are bolstered by experience with an implementation in the V distributed operating system.
Good news, bad news: experience building software development environment using the object-oriented paradigm
Authors: W. H. Harrison, P. F. Sweeney, J. J. Shilling
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1989)

This paper presents our experience building an extendible software development environment using the object-oriented paradigm. We have found that object instances provide a natural way to model program constructs, and to capture complex relationships between different aspects of a software system. The object-oriented paradigm can be efficiently implemented on standard hardware and software, and provides some degree of extendibility without requiring major modifications to the existing implementation. Unfortunately, we have also found that some natural extensions that we would like to make to the environment are not easily incorporated. We argue that the lack of extendibility is due to the object-oriented paradigm's lack of support for providing modifications and extensions to the object-oriented paradigm itself.
NSF initiatives in higher education: high-end computing
Authors: John Connolly
Venue: ACM SIGUCCS Newsletter (1988)

I am going to describe a few NSF activities which in some ways may make your life easier and in some ways may make your life a little more complicated. Our new NSF national supercomputing facility is, in a way, very complementary to the kinds of responsibilities that you have in a local computing facility. I like to think that we are offering a top-of-the-line scientific computing resource. Your faculty who will require top-of-the-line scientific computing will be using our centers, rather than your resources. Every computing center director knows physicists who want to use the whole machine and then cry for more. These people are the ones that we welcome at the national facility.
Degree complexity bounds on the intersection of algebraic curves
Authors: S. S. Abhyankar, S. Chandrasekar, V. Chandru
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

The intersection of algebraic curves in three and higher dimensional spaces is considered. An algebrogeometric technique is developed for obtaining an upper bound on the number of intersection points of two irreducible algebraic curves. The asymptotic bounds are shown to be a function of only the degrees of the two intersecting curves. Some specific examples involving curves in 3-space are analyzed.
Comments on &ldquo;security problems in the TCP/IP protocol suite&rdquo;
Authors: S. Kent
Venue: ACM SIGCOMM Computer Communication Review (1989)

In the April issue of Computer Communication Review, S. M. Bellovin described attacks on protocols in the TCP/IP suite [1]. He stated that the attacks were "inherent in the protocols, regardless of the correctness of any implementations." His article proposed specific defenses against these attacks and discussed more comprehensive defenses. This note attempts to place in perspective some of the concerns cited by Bellovin and to correct some errors present in his article, especially in his discussion of comprehensive defenses.
How to print floating-point numbers accurately
Authors: Guy L. Steele,  Jr., Jon L. White
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

We present algorithms for accurately converting floating-point numbers to decimal representation. The key idea is to carry along with the computation an explicit representation of the required rounding accuracy. We begin with the simpler problem of converting fixed-point fractions. A modification of the well-known algorithm for radix-conversion of fixed-point fractions by multiplication explicitly determines when to terminate the conversion process; a variable number of digits are produced. The algorithm has these properties: No information is lost; the original fraction can be recovered from the output by rounding. No &ldquo;garbage digits&rdquo; are produced. The output is correctly rounded. It is never necessary to propagate carries on rounding. We then derive two algorithms for free-formal output of floating-point numbers. The first simply scales the given floating-point number to an appropriate fractional range and then applies the algorithm for fractions. This is quite fast and simple to code but has inaccuracies stemming from round-off errors and oversimplification. The second algorithm guarantees mathematical accuracy by using multiple-precision integer arithmetic and handling special cases. Both algorithms produce no more digits than necessary (intuitively, the &ldquo;1.3 prints as 1.2999999&rdquo; problem does not occur). Finally, we modify the free-format conversion algorithm for use in fixed-format applications. Information may be lost if the fixed format provides too few digit positions, but the output is always correctly rounded. On the other hand, no &ldquo;garbage digits&rdquo; are ever produced, even if the fixed format specifies too many digit positions (intuitively, the &ldquo;4/3 prints as 1.333333328366279602&rdquo; problem does not occur).
Comments on Approximating Discrete Probability Distributions with Dependence Trees
Authors: S. K. M. Wong, F. C. S. Poon
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

C.K. Chow and C.N. Liu (1968) introduced the notion of three dependence to approximate a kth-order probability distribution. More recently, A.K.C. Wong and C.C. Wang (1977) proposed a different product approximation. The present authors show that the tree dependence approximation suggested by Chow and Liu can be derived by minimizing an upper bound of the Bayes error rate under certain assumptions. They also show that the method proposed by Wong and Wang does not necessarily lead to fewer misclassifications, because it is a special case of such a minimization procedure.
Separating and collapsing results on the relativized probabilistic polynomial-time hierarchy
Authors: Ker-I Ko
Venue: Journal of the ACM (JACM) (1990)

The probabilistic polynomial-time hierarchy (BPH) is the hierarchy generated by applying the BP-operator to the Meyer-Stockmeyer polynomial-time hierarchy (PH), where the BP-operator is the natural generalization of the probabilistic complexity class BPP. The similarity and difference between the two hierarchies BPH and PH is investigated. Oracles A and B are constructed such that both PH(A) and PH(B) are infinite while BPH(A) is not equal to PH(A) at any level and BPH(B) is identical to PH(B) at every level. Similar separating and collapsing results in the case that PH(A) is finite having exactly k levels are also considered.
Manuals that meet market demands
Authors: L. McClaren
Venue: Proceedings of the 7th annual international conference on Systems documentation (1989)

The greatest challenge you, the writer, will face when creating a manual is to design one that is used, a manual that the user loves, a manual with dog-eared pages, yellow highlighter and handwritten notes. Don't you wish your manuals would look as used as the yellow pages do after just one year's use? Yet, writers are also holders of manuals, many of which we do not use. Is there an out-of-date manual tucked into the bottom shelf of your bookcase, dusty with disuse? Do you know if it is even relevant anymore? The business community is littered with beautiful manuals, color-coded headings, amazing graphics&mdash;but they're useless, because the information is out of date. Sometimes it seems as though the writer had been trying to create a document like the U.S. Constitution, which has remained virtually unchanged in 200 years. Now there is a document that has stood the test of time. But it required 55 men almost 17 weeks to bring a document of 4,000 words to publication. Should we be striving for such immutability? Are we expecting to create manuals that will stand the test of time? Is this a realistic or even a practical goal? Or should we design our documents from the beginning for change? A manual is not a dead object, created once, then left on the shelf like a vase. It is a living, evolving document, that must be nurtured with new information, with new approaches. Without this evolution, it will die.