ppxscal/embedding_network huggingface dataset:
Parallel algorithm development workbench
Authors: S. Arya, B. Gaither
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

This paper proposes an approach, and a resulting tool, for developing algorithms for parallel processors. The problems in developing efficient algorithms for parallel systems are discussed. The objectives of this approach are to support the evaluation of the expected efficiency of algorithms on various interconnection network architectures before detailed code is written, optimization of interconnection network facility usage, and efficient evaluation of and tuning of codes (both systems and applications) to the CPU hardware. This proposed approach can be extended for the evaluation of alternative processor architectures as well. This approach and associated tool will take information about computation and communication times and provide information about elapsed time, idle spots, conflicts, and deadlocks. This is achieved by modeling various aspects of the system in different levels of detail. The Communications Network is modeled by a discrete event simulation with stochastic service assumptions. These stochastic service assumptions can be refined by the invocation of a cluster model which takes into account more details of resource contention and delays within a group of processors. Finally, a trace driven model of internal CPU timing can be used to replace statistical assumptions and represent precise timing of application code such as information on the extent to which chaining occurs and the utilization of functional units. These components work together to achieve the objectives discussed above. The proposed tool uses hierarchical simulation and provides a workbench environment for algorithm development. Transfer of data is represented via a high level notation which is independent of Interconnection Network architecture. The types of instrumentation and statistics required are discussed, as well as techniques under investigation for graphical representation of results. The structure of the simulator hierarchy, methods for extending the use of the model to evaluate real code, and the role of the modeling tool when used as part of a debugging environment are discussed. The processor model and the interpreter have currently been implemented. The remaining portions of the workbench are under incremental implementation.
Algorithmic Motion Planning in Robotics
Authors: Micha Sharir
Venue: Computer (1989)

A survey is presented of an approach to motion planning that emphasizes object-oriented, exact, and discrete (or combinatorial) algorithmic techniques in which worst-case asymptotically efficient solutions are being sought. Following a statement of the problem, motion planning in static and known environments is treated. The discussion covers general solutions, lower bounds, the projection method, the retraction method, the expanded obstacles, the single-component approach, and a mobile convex object moving in a 2D polygonal space. Variants of the motion-planning problem are then considered, namely, optimal motion planning, adaptive and exploratory motion planning, motion planning in the presence of moving obstacles, constrained motion planning, motion planning with uncertainty, and general task planning.
Early stopping in Byzantine agreement
Authors: Danny Dolev, Ruediger Reischuk, H. Raymond Strong
Venue: Journal of the ACM (JACM) (1990)

Two different kinds of Byzantine Agreement for distributed systems with processor faults are defined and compared. The first is required when coordinated actions may be performed by each participant at different times. This kind is called Simultaneous Byzantine Agreement (SBA). This paper deals with the number of rounds of message exchange required to reach Byzantine Agreement of either kind (BA). If an algorithm allows its participants to reach Byzantine agreement in every execution in which at most t participants are faulty, then the algorithm is said to tolerate t faults. It is well known that any BA algorithm that tolerates t faults (with t < n - 1 where n denotes the total number of processors) must run at least t + 1 rounds in some execution. However, it might be supposed that in executions where the number f of actual faults is small compared to t, the number of rounds could be correspondingly small. A corollary of our first result states that (when t < n - 1) any algorithm for SBA must run t + 1 rounds in some execution where there are no faults. For EBA (with t < n - 1), a lower bound of min(t + 1,f + 2) rounds is proved. Finally, an algorithm for EBA is presented that achieves the lower bound, provided that t is on the order of the square root of the total number of processors.
Real-Time Scheduling Theory and Ada
Authors: Lui Sha, John B. Goodenough
Venue: Computer (1990)

Rate monotonic scheduling theory puts real-time software engineering on a sound analytical footing. The authors review the theory and its implications for Ada.
A formulae-as-type notion of control
Authors: Timothy G. Griffin
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

The programming language Scheme contains the control construct call/cc that allows access to the current continuation (the current control context). This, in effect, provides Scheme with first-class labels and jumps. We show that the well-known formulae-as-types correspondence, which relates a constructive proof of a formula &agr; to a program of type &agr;, can be extended to a typed Idealized Scheme. What is surprising about this correspondence is that it relates classical proofs to typed programs. The existence of computationally interesting &ldquo;classical programs&rdquo; &mdash;programs of type &agr;, where &agr; holds classically, but not constructively &mdash; is illustrated by the definition of conjunctively, disjunctive, and existential types using standard classical definitions. We also prove that all evaluations of typed terms in Idealized Scheme are finite.
Protection and versioning for OCT
Authors: M. Silva, D. Gedye, R. Katz, R. Newton
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

This paper describes the extensions made for adding support for group development within the Oct/VEM CAD framework. In our implementation, a set of mechanisms has been incorporated into the Oct library. These contain support for versioning and concurrent access to Oct design objects. The mechanisms can be configured for establishment of specific design management styles. As an example, there is now support for organization of designs in terms of workspaces; but, the number of workspaces or the relationship between them must be established externally by a design management tool. Design management tools configure these mechanisms to establish policies to be followed by the other tools. With this architecture, integration of existing tools with distinct design management styles then becomes feasible.
The algorithm for calculating integrals of hypergeometric type functions and its realization in REDUCE system
Authors: V. S. Adamchik, O. I. Marichev
Venue: Proceedings of the international symposium on Symbolic and algebraic computation (1990)

The most voluminous bibliography of the analytical methods for calculating of integrals is represented in the article [19]. It is shown there that the most effective and the simplest algorithm of analytical integration was made by O.I. Marichev [8, 9, 12]. Later it was realized in the reference-books [16-18, 20]. This algorithm allows us to calculate definite and indefinite integrals of the products of elementary and special functions of hypergeometric type. It embraces about 70 per cent of integrals which are included in the world reference-literature. It allows to calculate many other integrals too. The present article contains short description of this algorithm and its realization in the REDUCE system during the process of creation of INTEGRATOR system. Only one general method of integration is known to be realized on the computers, i.e. criterion algorithm for calculating of indefinite integrals of elementary functions through elementary functions by themselves (the authors of it are M. Bronstein and other). The idea of our algorithm is in the following. The initial integrals is transformed to contour integral from the ratio of products of gamma-functions by means of Mellin transform and parseval equality. The residue theorem is used for the calculating of the received integral which due to the strict rules results in sums of hypergeometric series. The value of integral itself and the integrand functions are the special cases of the well-known Meijer's G-function [4, 7, 8, 12, 14, 18]. Programming packet is realized in programming languages PASCAL and REDUCE. It also offers the opportunity of finding the values for some classical integral transforms (Laplace, Hankel, Fourier, Mellin and etc.). The REDUCE's part of packet contains the main properties of the well-known special functions, such as the Bessel and gamma-functions and kindred functions, Anger function, Weber function, Whittaker functions, generalized hypergeometric functions. Special place in the packet is occupied by Meijers's G-function for which the main properties such as finding the particular cases and representation by means of hypergeometric series are realized.
Impact of self-scheduling order on performance on multiprocessor systems
Authors: P. Tang, P.-C. Yew, C.-Q. Zhu
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

Processor self-scheduling is an efficient dynamic scheduling for multiprocessors. This paper discusses the impact of the self-scheduling order on the performance of multiply-nested parallel loops. It is shown that, due to data synchronization for cross-iteration data dependencies, the completion time of a multiply-nested loop is reduced when the nesting parallel loops with smaller delays are moved to the inside. The best performance is achieved when a shortest-delay scheduling order is used. The performance of the shortest-delay self-scheduling is compared to other self-scheduling orders and to compile-time static scheduling order proposed elsewhere. Program transformation needed to implement shortest-delay self-scheduling is also included.
Knowledge Structuring and Constraint Satisfaction: The Mapsee Approach
Authors: Jan A. Mulder, Alan K. Mackworth, Willian S. Havens
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

Schema-based representations for visual knowledge are integrated with constraint satisfaction techniques. This integration is discussed in a progression of three sketch map interpretation programs: Mapsee-1, Mapsee-2, and Mapsee-3. The programs are evaluated by the criteria of descriptive and procedural adequacy. The evaluation indicates that a schema-based representation used in combination with a hierarchical arc-consistency algorithm constitutes a modular, efficient, and effective approach to the structured representation of visual knowledge. The schemata used in this representation are embedded in composition and specialization hierarchies. Specialization hierarchies are further expanded into discrimination graphs.
Pairwise Reduction for the Direct, Parallel Solution of Sparse, Unsymmetric Sets of Linear Equations
Authors: T. A. Davis, E. S. Davidson
Venue: IEEE Transactions on Computers (1988)

A paradigm for concurrent computing is explored in which a group of autonomous, asynchronous processes shares a common memory space and cooperates to solve a single problem. The processes synchronize with only a few others at a time; barrier synchronization is not permitted except at the beginning and end of the computation. The paradigm maps directly to a shared-memory multiprocessor with efficient synchronization primitives and is applied to the solution of a large, sparse system of linear equations. The algorithm, called pairwise solve (or PSolve), is presented with several variants to address some of the limitations of previous algorithms. On the Alliant FX/8, PSolve is faster than Gaussian elimination and two common sparse matrix algorithms.
Help by guided tasks: utilizing UIMS knowledge
Authors: Robin Tuck, Dan R. Olsen
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

A help delivery mechanism integrated with a semantic UIMS is presented. The guided task paradigm is implemented where a user participates in a guided step-by- step demonstration. Help authors create task scripts composed of statements drawn from the semantic definition of the user interface. The help delivery system automatically translates such statements into user instructions which guide the user through the actions necessary to accomplish a task. Any application developed using this UIMS automatically gets this help authoring and presentation facility with no added effort.
Modeling in Prolog
Authors: John Najarian
Venue: ACM SIGCSE Bulletin (1988)

Logic programming languages require a careful, incremental presentation in order to be understood by students of the standard von Neumann programming languages. In this paper, the characteristics and programming methodology of PROLOG are developed through a sequence of logic-oriented problems of increasing complexity. These activities are essential to fully understanding the mechanisms and internal behavior of this language and A.I. applications programs in general. In this approach, students are more motivated toward non-procedural logic. Even the problems alone have long been a source of interest in academic circles.
Almost-optimum speed-ups of algorithms for bipartite matching and related problems
Authors: Harold Gabow, Robert Tarjan
Venue: Proceedings of the twentieth annual ACM symposium on Theory of computing (1988)

We present algorithms for matching and related problems that run on an EREW PRAM with p processors. Given is a bipartite graph G with n vertices, m edges, and integral edge costs at most N in magnitude. We give an algorithm for the assignment problem (minimum cost perfect bipartite matching) that runs in &Ogr;(&radic;nm log (nN)(log(2p))/p) time and &Ogr;(m) space, for p &le; m/(&radic;nlog2n). For p = 1 this improves the best known sequential algorithm, and is within a factor of log (nN) of the best known bound for the problem without costs (maximum cardinality matching). For p > 1 the time is within a factor of log p of optimum speed-up. Extensions include an algorithm for maximum cardinality bipartite matching with slightly better processor bounds, and similar results for bipartite degree-constrained subgraph problems (with and without costs). Our ideas also extend to general graph matching problems.
Intrinsically parallel multiscale algorithms for hypercubes
Authors: P. Frederickson, O. A. McBryan
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

Most algorithms implemented on parallel computers have been optimal serial algorithms, slightly modified or parallelized. An exciting possibility is the search for intrinsically parallel algorithms. These are algorithms which do not have a sensible serial equivalent &mdash; any serial equivalent is so inefficient as to be of little use. We describe a multiscale algorithm for the solution of PDE systems that is designed specifically for massively parallel supercomputers. Unlike conventional multigrid algorithms, the new algorithm utilizes the same number of processors at all times. Convergence rates are much faster than for standard multigrid methods &mdash; the solution error decreases by up to three digits per iteration. The basic idea is to solve many coarse scale problems simultaneously, combining the results in an optimal way to provide an improved fine scale solution. On massively parallel machines the improved convergence rate is attained at no extra computational cost since processors that would otherwise be sitting idle are utilized to provide the better convergence. Furthermore the algorithm is ideally suited to SIMD computers as well as MIMD computers. On serial machines the algorithm is much slower than standard multigrid because of the extra time spent on multiple coarse scales, though in certain cases the improved convergence rate may justify this &mdash; primarily in cases where other methods do not converge. The algorithm provides an extremely fast solution of various standard elliptic equations on machines such as the 65,536 processor Connection Machine, and uses only &Ogr; (log(N)) parallel machine instructions to solve such equations. The discovery of this algorithm was motivated entirely by new hardware. It was a surprise to the authors to find that developments in computer architecture might lead to new mathematics. Undoubtedly further intrinsically parallel algorithms await discovery.
Rational for the design of reusable abstract data types implemented in Ada
Authors: C. Genillard, N. Ebel, A. Strohmeler
Venue: ACM SIGAda Ada Letters (1989)

Reusable abstract data types may be implemented in Ada as generic packages. First we will state some design goals, then outline our solution, address its rationale and show why alternatives have to be rejected. The presented design rules have already been applied successfully for implementing a rather wide set of abstract data types.
Natural Representations for Straight Lines and the Hough Transform on Discrete Arrays
Authors: I. D. Svalbe
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The grid of discrete sampled data points in a digital image supports a limited set of lines at angles and displacements 'natural' to that grid. The effect of this implicit line quantization on the parametrization of the Hough transform is presented. The function describing the discrete Hough transforms line-detection sensitivity is derived. Expressions for the orientation, frequency, and popularity of lines in the natural set are given. The results obtained are of importance to data arrays of small size. The distribution of lines in the natural set is also important as it determines the precision and reliability with which straight lines can be measured on a discrete imaging array. From the natural line set concept, a general (a,d) slope/offset straight-line parametrization is developed for which the Hough transform is compact and fast to compute, and which is as easy to interpret as the class (p, theta ) parametrization.
Perturbation Techniques for Detecting Domain Errors
Authors: Steven J. Zeil
Venue: IEEE Transactions on Software Engineering (1989)

Perturbation testing is an approach to software testing which focuses on faults withinarithmetic expressions appearing throughout a program. This approach is expanded to permit analysis of individual test points rather than entire paths, and to concentrate on domain errors. Faults are modeled as perturbing functions drawn from a vector space of potential faults and added to the correct form of an arithmetic expression. Sensitivity measures are derived which limit the possible size of those faults that would go undetected after the execution of a given test set. These measures open up an interesting view of testing, in which attempts are made to reduce the volume of possible faults which, were they present in the program being tested, would have escaped detection on all tests performed so far. The combination of these measures with standard optimization techniques yields a novel test-data-generation method called arithmetic fault detection.
A study of an advance organizer as a technique for teaching computer programming concepts
Authors: Katherine N. Macfarlane, Barbee T. Mynatt
Venue: ACM SIGCSE Bulletin (1988)

Research on instructional methods has suggested that advance organizers (e.g., metaphors) can be an effective tool in teaching certain types of material in some situations. In many cases, teaching computer programming concepts satisfies these criteria. In our research, beginning programming students were trained on the syntax of arrays. A training session consisted of reading a tutorial manual and entering lines of source code into an interactive system. One group was given a metaphorical organizer prior to training (an advance organizer). A second group received the organizer after training. A control group read a passage on computer history prior to training. The groups did not differ on training task performance or on a test of syntactic knowledge (near transfer). However, the advance organizer group did significantly better on a test of semantic knowledge (far transfer). Factors relating to when to use an advance organizer are discussed.
The periodic balanced sorting network
Authors: Martin Dowd, Yehoshua Perl, Larry Rudolph, Michael Saks
Venue: Journal of the ACM (JACM) (1989)

A periodic sorting network consists of a sequence of identical blocks. In this paper, the periodic balanced sorting network, which consists of log n blocks, is introduced. Each block, called a balanced merging block, merges elements on the even input lines with those on the odd input lines. The periodic balanced sorting network sorts n items in O([log n]2) time using (n/2)(log n)2 comparators. Although these bounds are comparable to many existing sorting networks, the periodic structure enables a hardware implementation consisting of only one block with the output of the block recycled back as input until the output is sorted. An implementation of our network on the shuffle exchange interconnection model in which the direction of the comparators are all identical and fixed is also presented.
ALIEN: a programming environment generator for personal computers
Authors: Ulrik Schroeder, Arno Spinner
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

Alien is a generator for interactive language-specific programming environments. The system makes a language definition environment available to the language definer and supports him with an interactive generator. Using these tools every syntactic unit of a language can be made available. This can be done by a method of stepwise testing, correction and expansion. Fully defined environments can easily be restricted to subsets of a language. This paper introduces a method making a large software product executable on small UNIX machines as well as a survey of the system's components. These are designed to make the implementation on PCs effective and to develop a powerful generator for programming environments. Therefore the results are of interest to all projects in the programming environment field. ALIEN has been implemented in C running on Siemens PC-X, PC-X10, PC-MX-2 machines and Atari PC. Implementation on Apollo and SUN workstations is still in progress and on IBM PC is planned. The project is supported by the Stiftung Volkswagen-werk under grant 1/61 602.
An efficient radiosity solution for bump texture generation
Authors: Hong Chen, En-Hua Wu
Venue: Proceedings of the 17th annual conference on Computer graphics and interactive techniques (1990)

The development of global illumination and texture generation makes it possible to produce the most realistic images. However, it is still difficult or deficient so far to simulate bump texture effects while the interreflection of light being modeled by the present ray tracing or radiosity methods. A method of bump texture generation, being incorporated into the process of radiosity solution, is presented in the paper. The method is characterized by introduction of a perturbed radiosity map, established in the context of either progressive radiosity or standard radiosity solution. To calculate the perturbed radiosity, a concept of perturbed form-factors is proposed, and the algorithms for evaluating the perturbed form-factors are also given. As a result, a bilinear-interpolation shading scheme for perturbed surfaces is provided, and the texturing method is easily added to a newly improved solution of progressive refinement radiosity for non-diffuse environment.