ppxscal/embedding_network huggingface dataset:
Efficient Methods for Multi-Dimensional Array Redistribution
Authors: Ching-Hsien Hsu, Yeh-Ching Chung, Chyi-Ren Dow
Venue: The Journal of Supercomputing (2000)

In many scientific applications, array redistribution is usually required to enhance data locality and reduce remote memory access on distributed memory multicomputers. Since the redistribution is performed at run-time, there is a performance tradeoff between the efficiency of the new data decomposition for a subsequent phase of an algorithm and the cost of redistributing data among processors. In this paper, we present efficient methods for multi-dimensional array redistribution. Based on the previous work, the basic-cycle calculation technique, we present a basic-block calculation (BBC) and a complete-dimension calculation (CDC) techniques. We also developed a theoretical model to analyze the computation costs of these two techniques. The theoretical model shows that the BBC method has smaller indexing costs and performs well for the redistribution with small array size. The CDC method has smaller packing/unpacking costs and performs well when array size is large. When implemented these two techniques on an IBM SP2 parallel machine along with the PITFALLS method and the Prylli's method, the experimental results show that the BBC method has the smallest execution time of these four algorithms when the array size is small. The CDC method has the smallest execution time of these four algorithms when the array size is large.
On the capabilities of while, repeat, and exit statements
Authors: W. W. Peterson, T. Kasami, N. Tokura
Venue: Communications of the ACM (1973)

A well-formed program is defined as a program in which loops and if statements are properly nested and can be entered only at their beginning. A corresponding definition is given for a well-formed flowchart. It is shown that a program is well formed if and only if it can be written with if, repeat, and multi-level exit statements for sequence control. It is also shown that if, while, and repeat statements with single-level exit do not suffice. It is also shown that any flowchart can be converted to a well-formed flowchart by node splitting. Practical implications are discussed.
Generalized Inversion Attack on Nonlinear Filter Generators
Authors: Jovan Dj. Golic, Andrew Clark, Ed Dawson
Venue: IEEE Transactions on Computers (2000)

A nonlinear filter generator is a basic keystream generator for stream cipher applications consisting of a single linear feedback shift register whose output is filtered by a nonlinear combining function. A binary nonlinear filter generator is viewed as a finite input memory automaton with one binary input and one binary output. The generalized inversion attack on a binary nonlinear filter generator is developed and analyzed by the theory of critical branching processes. Its objective is to recover the unknown input sequence from a given segment of the output sequence, provided that the filter function is known. Unlike the inversion attack, which requires that the filter function be linear in the first or the last input variable, this attack can be applied for any filter function. Both theory and systematic experiments show that its time complexity remains close to $2^M$, which is the time complexity of the inversion attack, where $M$ denotes the input memory size in bits.
Analysis of Timed Systems Using Time-Abstracting Bisimulations
Authors: Stavros Tripakis, Sergio Yovine
Venue: Formal Methods in System Design (2001)

The objective of this paper is to show how verification of dense-time systems modeled as timed automata can be effectively performed using untimed verification techniques. In that way, the existing rich infrastructure in algorithms and tools for the verification of untimed systems can be exploited. The paper completes the ideas introduced in (Tripakis and Yovine, 1996, in Proc. 8th Conf. Computer-Aided Verification, CAV'96, Rutgers, NJ. LNCS, Vol. 1102, Springer-Verlag, 1996, pp. 232&ndash;243).Our approach consists in two steps. First, given a timed system A, we compute a finite graph G which captures the behavior of A modulo the fact that exact time delays are abstracted away. Then, we apply untimed verification techniques on G to prove properties on A. As property-specification languages, we use both the linear-time formalism of timed B&uuml;chi automata (TBA) and the branching-time logic TCTL. Model checking A against properties specified as TBA or TCTL formulae comes down to applying, respectively, automata-emptiness or CTL model-checking algorithms on G.The abstraction of exact delays is formalized under the concept of time-abstracting bisimulations. We define three time-abstracting bisimulations which are strictly ordered with respect to their reduction power. The stronger of them preserves both linear- and branching-time properties whereas the two weaker ones preserve only linear-time properties.The finite graph G is the quotient A with respect to a time-abstracting bisimulation. Generating G is called minimization and can be done by adapting a partition-refinement algorithm to the timed case. The adapted algorithm is symbolic, that is, equivalence classes are represented as simple polyhedra. When these polyhedra are not convex, operations become expensive, therefore, we develop a partition-refinement technique which preserves convexity.We have implemented the minimization algorithm in a prototype module called minim, as part of the real-time verification platform KRONOS (Bozga et al., 1998, in CAV'98). minim connects KRONOS to the CADP tool suite for the verification of untimed graphs (Fernandez et al., 1992, in 14th Int. Conf. on Software Engineering). To demonstrate the practical interest behind our approach, we present two case studies, namely, Fischer's mutual exclusion protocol and the CSMA/CD communication protocol.
Making parallel programming accessible to inexperienced programmers through cooperative learning
Authors: Lori Pollock, Mike Jochen
Venue: ACM SIGCSE Bulletin (2001)

This paper describes how we utilized cooperative learning to meet the practical challenges of teaching parallel programming in the early college years, as well as to provide a more real world context to the course. Our main contribution is a set of cooperative group activities for both inside and outside the classroom, which are targeted to the computer science discipline, have received very positive student feedback, are easy to implement, and achieve a number of learning objectives beyond knowledge of the specific topic. These activities can be applied directly or be easily adapted to other computer science courses, particularly programming, systems, and experimental computer science courses.
Formal verification of parallel programs
Authors: Robert M. Keller
Venue: Communications of the ACM (1976)

Two formal models for parallel computation are presented: an abstract conceptual model and a parallel-program model. The former model does not distinguish between control and data states. The latter model includes the capability for the representation of an infinite set of control states by allowing there to be arbitrarily many instruction pointers (or processes) executing the program. An induction principle is presented which treats the control and data state sets on the same ground. Through the use of &ldquo;place variables,&rdquo; it is observed that certain correctness conditions can be expressed without enumeration of the set of all possible control states. Examples are presented in which the induction principle is used to demonstrate proofs of mutual exclusion. It is shown that assertions-oriented proof methods are special cases of the induction principle. A special case of the assertions method, which is called parallel place assertions, is shown to be incomplete. A formalization of &ldquo;deadlock&rdquo; is then presented. The concept of a &ldquo;norm&rdquo; is introduced, which yields an extension, to the deadlock problem, of Floyd's technique for proving termination. Also discussed is an extension of the program model which allows each process to have its own local variables and permits shared global variables. Correctness of certain forms of implementation is also discussed. An Appendix is included which relates this work to previous work on the satisfiability of certain logical formulas.
An improved lower bound for the time complexity of mutual exclusion
Authors: James H. Anderson, Yong-Jik Kim
Venue: Proceedings of the twentieth annual ACM symposium on Principles of distributed computing (2001)

We establish a lower bound of &OHgr;(log N/log log N) remote memory references for N-process mutual exclusion algorithms based on reads, writes, or comparison primitives. Our bound improves an earlier bound of &OHgr;(log log N/log log log N) established by Cypher.
Formal parsing systems
Authors: Sheila A. Greibach
Venue: Communications of the ACM (1964)

Automatic syntactic analysis has recently become important for both natural language data processing and syntax-directed compilers. A formal parsing system G = (V, &mgr;, T, R) consists of two finite disjoint vocabularies, V and T, a many-many map, &mgr;, from V onto T, and a recursive set R of strings in T called syntactic sentence classes. Every program for automatic syntactic analysis determines a formal parsing system. A directed production analyzer (I, T, X, &rgr;) is a nondeterministic pushdown-store machine with internal vocabulary I, input vocabulary T, and all productions of &rgr; in the form: (Z, a) &rarr; aY1 &middot;&middot;&middot; Ym, Z, Yi &egr; I, a &egr; T. Every context-free language can be analyzed by a directed production analyzer.
Comments on a recent paper0
Authors: J. F. Traub
Venue: Communications of the ACM (1960)

Mr. Diran Sarafyan, in his paper &ldquo;A New Method of Computation of Square Roots Without Using Divisions&rdquo; (Communications, Nov. 1959) gave a way of computing square roots which converges faster than the standard Newton method. His technique can be generalized as follows.
Algorithm = logic + control
Authors: Robert Kowalski
Venue: Communications of the ACM (1979)

The notion that computation = controlled deduction was first proposed by Pay Hayes [19] and more recently by Bibel [2] and Vaughn-Pratt [31]. A similar thesis that database systems should be regarded as consisting of a relational component, which defines the logic of the data, and a control component, which stores and retrieves it, has been successfully argued by Codd [10]. Hewitt's argument [20] for the programming language PLANNER, though generally regarded as an argument against logic, can also be regarded as an argument for the thesis that algorithms be regarded as consisting of both logic and control components. In this paper we shall explore some of the useful consequences of that thesis.
Gauss harmonic interpolation formulas
Authors: A. H. Stroud
Venue: Communications of the ACM (1974)

Let R be an open, bounded, simply connected region in the (x,y)-plane and let (x*,y*) be a point in R. Assuming R is starlike with respect to (x*,y*), we discuss a method for computing Gauss harmonic interpolation formulas for R and the point (x*,y*). Such formulas approximate a harmonic function at (x*,y*) in terms of a linear combination of its values at certain selected points on the boundary of R. Such formulas are useful for approximating the solution of the Dirichlet problem for R.
Interactive execution of distributed algorithms
Authors: Mordechai Ben-Ari
Venue: Journal on Educational Resources in Computing (JERIC) (2001)

DAJ (Distributed Algorithms in Java) is a framework for writing Java programs to implement distributed algorithms. The programs display the data structures at each node and enable the user to interactively construct scenarios. In a learning situation, active interactive execution is preferable to passively watching an animation. Programs have been implemented for commonly taught algorithms, including the Byzantine generals, mutual exclusion, termination, and snapshots. Adding a program for another algorithm requires only general Java programming experience, as the GUI aspects are encapsulated.
Program Development Tools for Clusters of Shared Memory Multiprocessors
Authors: B. Chapman, J. Merlin, D. Pritchard, F. Bodin, Y. Mevel, T. Sørevik, L. Hill
Venue: The Journal of Supercomputing (2000)

Applications are increasingly being executed on computational systems that have hierarchical parallelism. There are several programming paradigms which may be used to adapt a program for execution in such an environment. In this paper, we outline some of the challenges in porting codes to such systems, and describe a programming environment that we are creating to support the migration of sequential and MPI code to a cluster of shared memory parallel systems, where the target program may include MPI, OpenMP or both. As part of this effort, we are evaluating several experimental approaches to aiding in this complex application development task.
VIDEX: an integrated generic video indexing approach
Authors: Roland Tusch, Harald Kosch, Lázló Böszörményi
Venue: Proceedings of the eighth ACM international conference on Multimedia (2000)

This paper presents an integrated generic technique for low-and high-level video indexing. The proposed approach tries to integrate the advantages of existing low- and high-level video indexing approaches by reducing their shortcomings. Furthermore, the model introduces concepts for a detailed structuring of video streams, and for correlations of low-and high-level video objects. The proposed model is called generic, as it only defines a framework of classes for an implementating a prototype of a distibuted multimedia information system supporting content-based video retrieval.
Biometric Identification through Hand Geometry Measurements
Authors: Raul Sanchez-Reillo, Carmen Sanchez-Avila, Ana Gonzalez-Marcos
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (2000)

A work in defining and implementing a biometric system based on hand geometry identification is presented here. Hand features are extracted from a color photograph taken when the user has placed his hand on a platform designed for such a task. Different pattern recognition techniques have been tested to be used in classification and/or verification from Euclidean distance to neural networks. Experimental results, up to a 97 percent rate of success in classification, will show the possibility of using this system in medium/high security environments with full acceptance from all users.
Texture compression with adaptive block partitions (poster session)
Authors: Leonid Levkovich-Maslyuk, Pavel Kalyuzhny, Alexander Zhirkov
Venue: Proceedings of the eighth ACM international conference on Multimedia (2000)

We present image compression method based on block palletizing. Image block is partitioned into four subsets, and each subset is palletized by 2 or 4 colors from the quasioptimal local palette, constructed for the whole block. Index map for the whole block, being the union of index maps for subsets, is thus only 1 or 2 bits deep, while the local palette may consist of 8 or even 16 colors. The local palette has a specific geometrical configuration in RGB color space, determined by only 2 colors. These two colors are stored explicitly, and the rest are reconstructed at the decompression stage. Compressed block consists, essentially, of the index map, palette description and partition description. This format allows fast access to randomly chosen pixels, and high reconstruction quality for compression ratios from 8 to 12, which is useful for texture storage in 3D graphics applications where real-time decompression is crucial.
A study of line overhead in the Arpanet
Authors: Leonard Kleinrock, William E. Naylor, Holger Opderbeck
Venue: Communications of the ACM (1976)

The form, extent, and effect of the communication line overhead in the ARPANET are considered. The source of this overhead is separated into various levels of protocol hierarchy and the characteristics of each level are summarized. Then the line efficiency for various models of system use is studied. Some measurements of line efficiency for the ARPANET are presented and by extrapolation these measurements are used to anticipate overhead in a heavily loaded network. Similar results are derived for a recently proposed network protocol and compared with those for the current system.
Analytic differentiation by computer
Authors: James W. Hanson, Jane Shearin Caviness, Camilla Joseph
Venue: Communications of the ACM (1962)

During the past few years a major portion of the work in computer applications has been concentrated in the two closely related fields of automatic programming and symbol manipulation. The results of this effort have been a wealth of new computer languages, a better understanding and definition of the basic principles and problems of symbol manipulation, and a growing body of algorithms and techniques for use in the applications.
Theoretical and Numerical Analysis of an Optimal Control Problem Related to Wastewater Treatment
Authors: A. Martínez, C. Rodríguez, M. E. Vázquez-Méndez
Venue: SIAM Journal on Control and Optimization (2000)

In this work we deal with the design and management of wastewater treatment systems, mainly the disposal of sea outfalls discharging polluting effluent from a sewerage system. This problem is formulated as a pointwise optimal control problem with state and control constraints. The main difficulties arise from the lack of regularity of the second member in the state system and from the pointwise constraints on the state variables. We develop the theoretical analysis of the problem, we propose an algorithm for its numerical resolution, and finally, we give results for a realistic problem posed in the r&iacute;a of Vigo, Spain.
Simulation of outpatient appointment systems
Authors: Jesse H. Katz
Venue: Communications of the ACM (1969)

An experimental computer program is described which simulates appointment systems employed by outpatient departments of hospitals. Both major kinds of appointment systems&mdash;individual and block&mdash;can be simulated. The purpose of the Simulator is to enable the user to evaluate the effectiveness of alternative appointment systems in a given clinical environment.
Improving memory performance of sorting algorithms
Authors: Li Xiao, Xiaodong Zhang, Stefan A. Kubricht
Venue: Journal of Experimental Algorithmics (JEA) (2000)

Memory hierarchy considerations during sorting algorithm design and implementation play an important role in significantly improving execution performance. Existing algorithms mainly attempt to reduce capacity misses on direct-mapped caches. To reduce other types of cache misses that occur in the more common set-associative caches and the TLB, we restructure the mergesort and quicksort algorithms further by integrating tiling, padding, and buffering techniques and by repartitioning the data set. Our study shows that substantial performance improvements can be obtained using our new methods.
Octree based assembly sequence generation
Authors: Raymond C. W. Sung, Jonathan R. Corney, Doug E. R. Clark
Venue: Proceedings of the sixth ACM symposium on Solid modeling and applications (2001)

This paper describes a system for the automatic recognition of assembly features and the generation of assembly/disassembly sequences. The paper starts by reviewing the nature and use of assembly features. One of the conclusions drawn from this survey is that the majority of assembly features involve sets of spatially adjacent faces. Two principle types of adjacency relationships are identified and an algorithm is presented for identifying assembly features which arise from &ldquo;spatial&rdquo; and &ldquo;contact&rdquo; face adjacency relationships (known as s-adjacency and c-adjacency respectively). The algorithm uses an octree representation of a B-rep model to support the geometric reasoning required to locate assembly features on disjoint bodies. A pointerless octree representation is generated by recursively sub-dividing the assembly model's bounding box into octants which are used to locate: Those portions of faces which are c-adjacent (i.e. they effectively touch within the tolerance of the octree). Those portions of faces which are s-adjacent to a nominated face. The resulting system can locate and partition spatially adjacent faces in a wide range of situations and a different resolutions. The assembly features located are recorded as attributes in the B-rep model and are then used to generate a disassembly sequence plan for the assembly. This sequence plan is represented by a transition state tree which incorporates knowledge of the availability of feasible gripping features. By way of illustration, the algorithm is applied to several trial components
PSBLAS: a library for parallel linear algebra computation on sparse matrices
Authors: Salvatore Filippone, Michele Colajanni
Venue: ACM Transactions on Mathematical Software (TOMS) (2000)

Many computationally intensive problems in engineering and science give rise to the solution of large, sparse, linear systems of equations. Fast and efficient methods for their soltion are very important because these systems usually occur in the innermost loop of the computational scheme. Parallelization is often necessary to achieve an acceptable level of performance. This paper presents the design, implementation, and interface of a library of Basic Linear Algebra Subroutines for sparse matrices (PSBLAS) which is specifically tailored to distributed-memory computers. PSBLAS enables easy, efficient, and portable implementations of parallel iterative solvers for linear systems. The interface keeps in view a Single Program Multiple Data programming model on distributed-memory machines. However, the architecture of the library does not exclude an implementation in different paradigms, such as those based on the shared-memory model.
Impact of job mix on optimizations for space sharing schedulers
Authors: Jaspal Subhlok, Thomas Gross, Takashi Suzuoka
Venue: Proceedings of the 1996 ACM/IEEE conference on Supercomputing (CDROM) (1996)

This paper addresses job scheduling for parallel supercomputers. Modern parallel systems with n nodes can be used by jobs requesting up to n nodes. If less than n nodes are requested, multiple jobs can be run at the same time, allowing several users to use the system. One of the challenges for the operating system is to give reasonable service to a diverse group of requests. A single 1-node job that is running for a long time may effectively block the whole machine if the next job requests all n nodes. To date various policies have been proposed for the scheduling highly parallel computers. But as the users of current supercomputers know, these policies work far from perfect. This paper reports on the measurement of the usage of a 96-node Intel Paragon at ETH Zurich, a 512 node IBM SP2 at Cornell Theory Center, and a 512 node Cray T3D at Pittsburgh Supercomputing Center. We discuss the common characteristics of the different workloads and identify their impact on job scheduling techniques for such parallel systems. The metrics used for evaluating scheduling are based on turnaround time and fairness among jobs. We specifically show how two simple scheduling optimizations based on reordering the waiting queue can be used to effectively improve scheduling performance on real workloads. An important contribution of this paper is to establish that supercomputer workloads do exhibit some common characteristics but they also differ in important ways, and the knowledge of workloads is important for design of effective scheduling algorithms. Given the current ad-hoc approach applied to tuning the scheduler systems, these results are of interest to scheduling researchers, supercomputer installations, and developers of scheduling software.