ppxscal/embedding_network huggingface dataset:
A parallel B-spline surface fitting algorithm
Authors: Fuhua Cheng, Ardeshir Goshtasby
Venue: ACM Transactions on Graphics (TOG) (1988)

A parallel fitting algorithm using uniform bicubic B-spline surfaces is presented. This algorithm is based on the observation that a tensor product spline surface fitting problem can be split into two spline curve fitting problems, and each of these problems can be carried out in parallel by cyclic reduction. Using this approach, the control points of a uniform bicubic B-spline surface that interpolates a grid of m x n points can be found in O(log m + log n) time on mn processors. Furthermore, since smaller systems of equations are solved in the algorithm, the accumulated error resulting from this approach is smaller than that of the traditional algorithms.
Towards modeling the performance of a fast connected components algorithm on parallel machines
Authors: Steven S. Lumetta, Arvind Krishnamurthy, David E. Culler
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

We present and analyze a portable, high-performance algorithm for finding connected components on modern distributed memory multiprocessors. The algorithm is a hybrid of the classic DFS on the subgraph local to each processor and a variant of the Shiloach-Vishkin PRAM algorithm on the global collection of subgraphs. We implement the algorithm in Split-C and measure performance on the the Cray T3D, the Meiko CS-2, and the Thinking Machines CM-5 using a class of graphs derived from cluster dynamics methods in computational physics. On a 256 processor Cray T3D, the implementation outperforms all previous solutions by an order of magnitude. A characterization of graph parameters allows us to select graphs that highlight key performance features. We study the effects of these parameters and machine characteristics on the balance of time between the local and global phases of the algorithm and find that edge density, surface-to-volume ratio, and relative communication cost dominate performance. By understanding the effect of machine characteristics on performance, the study sheds light on the impact of improvements in computational and/or communication performance on this challenging problem.
Asynchronous updates in large parallel systems
Authors: Albert G. Greenberg, S. Shenker, Alexander L. Stolyar
Venue: Proceedings of the 1996 ACM SIGMETRICS international conference on Measurement and modeling of computer systems (1996)

Lubachevsky [5] introduced a new parallel simulation technique intended for systems with limited interactions between their many components or sites. Each site has a local simulation time, and the states of the sites are updated asynchronously. This asynchronous updating appears to allow the simulation to achieve a high degree of parallelism, with very low overhead in processor synchronization. The key issue for this asynchronous updating technique is: how fast do the local times make progress in the large system limit? We show that in a simple K-random interaction model the local times progress at a rate 1/(K + 1). More importantly, we find that the asymptotic distribution of local times is described by a traveling wave solution with exponentially decaying tails. In terms of the parallel simulation, though the interactions are local, a very high degree of global synchronization results, and this synchronization is succinctly described by the traveling wave solution. Moreover, we report on experiments that suggest that the traveling wave solution is universal; i.e., it holds in realistic scenarios (out of reach of our analysis) where interactions among sites are not random.
Inside simulation software: how it works and why it matters
Authors: Thomas J. Schriber, Daniel T. Brunner
Venue: Proceedings of the 27th conference on Winter simulation (1995)

This paper provides beginning and intermediate simulation practitioners and interested simulation consumers with a grounding in how discrete-event simulation software works. Topics include discrete-event systems and modeling; entities and resources; simulation runs; entity states; entity lists; and list management. The implementation of these generic ideas in SIMAN, ProModel, and GPSS/H is described. The paper concludes with several examples of "why it matters" for modelers to know in fine detail how their simulation software works.
Designing closed laboratories for a computer science course
Authors: Alan Fekete, Antony Greening
Venue: ACM SIGCSE Bulletin (1996)

A recent trend has been to accompany Computer Science courses by "closed laboratories" where students carried out tasks with supervision and guidance. This paper presents a methodology for designing a complete sequence of laboratories to support the instruction in a course. The design considers both the technical concepts to be conveyed and the learning experiences through which students learn. We demonstrate the way the methodology has been used to design the lab sequence for a Pascal-based CS1 course.
The design of a new frontal code for solving sparse, unsymmetric systems
Authors: I. S. Duff, J. A. Scott
Venue: ACM Transactions on Mathematical Software (TOMS) (1996)

We describe the design, implementation, and performance of a frontal code for the solution of large, sparse, unsymmetric systems of linear equations. The resulting software package, MA42, is included in Release 11 of the Harwell Subroutine Library and is intended to supersede the earlier MA32 package. We discuss in detail the extensive use of higher-level BLAS kernels within MA42 and illustrate the performance on a range of practical problems on a CRAY Y-MP, an IBM 3090, and an IBM RISC System/6000. We examine extending the frontal solution scheme to use multiple fronts to allow MA42 to be run in parallel. We indicate some directions for future development.
Power over users: its exercise by system professionals
Authors: M. Lynne Markus, Niels Bjørn-Andersen
Venue: Communications of the ACM (1987)

Analysis and awareness of the types of power that IS professionals exercise over users can improve the productivity of both parties.
Aggregation with an error of O(&egr;2)
Authors: Hendrik Vantilborgh
Venue: Journal of the ACM (JACM) (1985)

An aggregative technique to obtain an improved approximation of the equilibrium vector of a Markov chain with a nearly completely decomposable transition matrix is presented. The technique is demonstrated on a model of a multiprogrammed computer system.
Signature matching: a tool for using software libraries
Authors: Amy Moormann Zaremski, Jeannette M. Wing
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (1995)

Signature matching is a method for organizing, navigating through, and retrieving from software libraries. We consider two kinds of software library components&mdash;functions and modules&mdash;and hence two kinds of matching&mdash;function matching and module matching. The signature of a function is simply its type; the signature of a module is a multiset of user-defined types and a multiset of function signatures. For both functions and modules, we consider not just exact match but also various flavors of relaxed match. We describe various applications of signature matching as a tool for using software libraries, inspired by the use of our implementation of a function signature matcher written in Standard ML.
Unconstrained speculative execution with predicated state buffering
Authors: Hideki Ando, Chikako Nakanishi, Tetsuya Hara, Masao Nakaya
Venue: Proceedings of the 22nd annual international symposium on Computer architecture (1995)

Speculative execution is execution of instructions before it is known whether these instructions should be executed. Compiler-based speculative execution has the potential to achieve both a high instruction per cycle rate and high clock rate. Pure compiler-based approaches, however, have greatly limited instruction scheduling due to a limited ability to handle side effects of speculative execution. Significant performance improvement is, thus, difficult in non-numerical applications. This paper proposes a new architectural mechanism, called predicating, which provides unconstrained speculative execution. Predicating removes restrictions which limit the compiler's ability to schedule instructions. Through our hardware support, the compiler is allowed to move instructions past multiple basic block boundaries from any succeeding control path. Predicating buffers the side effects of speculative execution with its predicate, and the buffered predicate efficiently commits or squashes the side effects. The mechanism also provides a speculative exception handling scheme. The scheme, called the future condition, properly postpones speculative exceptions and efficiently restarts the process. We show that our mechanism can be implemented through a modest amount of hardware with little complexity. The evaluation results show that our mechanism significantly improves performance, and achieves a 2.45x speedup over scalar machines.
Transparent remote execution in LAHNOS by means of a neural network device
Authors: M. Cena, M. L. Crespo, R. Gallard
Venue: ACM SIGOPS Operating Systems Review (1995)

LAHNOS is a Local Area Heterogeneous Operating System [1] being currently developed at the Universidad Nacional de San Luis over which distributed services are to be built. This paper shows some enhancements to be introduced into the original design in order to achieve automatic allocation of remote execution requests to the best fitted node under some chosen performance criteria.Following current trends in Distributed Systems we propose the insertion of a neural network device into the kernel of LAHNOS to reflect a selected allocation policy to provide improved system performance as long as to release the user of some cumbersome decisions.
Storage use analysis and its applications
Authors: Manuel Serrano, Marc Feeley
Venue: Proceedings of the first ACM SIGPLAN international conference on Functional programming (1996)

In this paper we present a new program analysis method which we call Storage Use Analysis. This analysis deduces how objects are used by the program and allows the optimization of their allocation. This analysis can be applied to both statically typed languages (e.g. ML) and latently typed languages (e.g. Scheme). It handles side-effects, higher order functions, separate compilation and does not require CPS transformation. We show the application of our analysis to two important optimizations: stack allocation and unboxing. The first optimization replaces some heap allocations by stack allocations for user and system data storage (e.g. lists, vectors, procedures). The second optimization avoids boxing some objects. This analysis and associated optimitations have been implemented in the Bigloo Scheme/ML compiler. Experimental results show that for many allocation intensive programs we get a significant speedup. In particular, numerically intensive programs are almost 20 times faster because floating point numbers are unboxed and no longer heap allocated.
Constructing Huffman Trees in Parallel
Authors: Lawrence L. Larmore, Teresa M. Przytycka
Venue: SIAM Journal on Computing (1995)

We present a parallel algorithm for the Huffman coding problem. We reduce the Huffman coding problem to the concave least weight subsequence problem and give a parallel algorithm that solves the latter problem in $O(\sqrt n \log n)$ time with $n$ processors on a concurrent read exclusive write parameter random-access machine (CREW PRAM). This leads to the first sublinear time $o(n^2)$-total work parallel algorithm for Huffman coding. This reduction of the Huffman coding problem to the CLWS problem also yields an alternative $O(n \log n)$-time (or linear-time, for a sorted input sequence) algorithm for Huffman coding.
On the distribution and convergence of feature space in self-organizing maps
Authors: Hujun Yin, Nigel M. Allinson
Venue: Neural Computation (1995)

In this paper an analysis of the statistical and the convergence properties of Kohonen's self-organizing map of any dimension is presented. Every feature in the map is considered as a sum of a number of random variables. We extend the Central Limit Theorem to a particular case, which is then applied to prove that the feature space during learning tends to multiple gaussian distributed stochastic processes, which will eventually converge in the mean-square sense to the probabilistic centers of input subsets to form a quantization mapping with a minimum mean squared distortion either globally or locally. The diminishing effect, as training progresses, of the initial states on the value of the feature map is also shown.
Economic aspects of configuring cellular networks
Authors: Bezalel Gavish, Suresh Sridhar
Venue: Wireless Networks (1995)

This paper addresses economic aspects of configuring cellular networks. Major components of costs and revenues and the major stakeholders are identified and a model is developed to determine the system configuration (e.g. cell size, number of channels, etc.) which will maximize the annual expected net revenues to the system operator. Key properties relating the various parameters of interest are derived. The results of computational experiments are presented and their implications are discussed. The computational results show that the optimal net revenue curves have a saw-tooth structure with two types of teeth; Large ones that come from switching between cellular technologies, and smaller jumps come the discretenes of base stations. The importance of capturing a high fraction of potential users, in early stages of cellular system introduction is investigated. Finally, the cost of competition and its implications for the regulatory agency and the cellular service providers are analyzed. It is shown that by dividing the available frequency spectrum between too many system operators, the overall value of the cellular system is reduced when compared to an approach which uses division of the overall service area into a larger number of service areas, each with only two system operatos. The above results have profound implications on public policies for frequency spectrum allocation.
Efficient use of large don't cares in high-level and logic synthesis
Authors: R. A. Bergamaschi, D. Brand, L. Stok, M. Berkelaar, S. Prakash
Venue: Proceedings of the 1995 IEEE/ACM international conference on Computer-aided design (1995)

This paper describes optimization techniques using don't-care conditions that span the domain of high-level and logic synthesis. The following three issues are discussed: 1) how to describe and extract don't-care conditions from high-level descriptions; 2) how to pass don't-care conditions from high-level to logic synthesis; and 3) how to optimize the logic using don't-care conditions. Efficient techniques are given for these three problems which allow the use of large don't-care sets. Results from several examples demonstrate that these techniques are very effective for both area and delay minimization.
Using continued fractions for efficient subclass checking
Authors: R. Morrison, A. England, R. C. H. Connor, M. P. Atkinson, S. Barneva, F. Rabitti, P. Zezula
Venue: ACM SIGPLAN OOPS Messenger (1995)

Dynamic subclass checks are common in many sub-paradigms of object-oriented programming. These checks may be simply implemented by following the superclass chain through the objects which represent the class hierarchy. However, in large or data-intensive applications, such as OODBMS, this simple checking strategy may have significant efficiency consequences. Very long class chains, which commonly occur, can cause much pointer following, which in turn has a knock-on effect on the overall performance of memory management. Measurements have shown that memory management is the most significant factor in the performance of large object-oriented systems.This paper describes a way of testing if one class is a subclass of another without involving any pointer accesses. On creation, each class is allocated a unique pair of integers, over which subclass tests may be performed using only arithmetic. The technique only works for single inheritance systems; the essence of the technique is to simulate the tree structure of the class hierarchy using the well-understood mathematical model of continued fractions.
An educational project in computer science for primary and high school
Authors: Marcelo Zanconi, Norma Moroni, Perla Señas
Venue: ACM SIGCSE Bulletin (1995)

We analyze four different points of view in the teaching of computer science at school, taking into account the aims of institutions, i.e, computer sciences as a formative, operational, informative and pedagogical tool.We present a particular experience that links the four points of view proposed in a curriculum for primary and high school. This is the result of a two year work developed under a project between our research group, InE, and a private institution of our city. We believe our approach is quite original because these four points of view were traditionally considered as opposites.
Analyzing and communicating usability data: now that you have the data what do you do? a CHI'94 workshop
Authors: Nandini P. Nayak, Debbie Mrazek, David R. Smith
Venue: ACM SIGCHI Bulletin (1995)

At the CHI '94 Workshop: "Analyzing and Communicating Usability Data", usability researchers and practitioners gathered to discuss how usability data should be collected, analyzed, and communicated to help ensure the design and development of usable products. This workshop was motivated by the challenges CHI practitioners have encountered in analyzing and communicating data despite the widespread availability of a variety of usability tools. Workshop activities included brief presentations, small group discussions, and rating exercises that involved evaluating analysis and communication techniques discussed during the workshop. Some of the questions addressed during the workshop included: what makes analysis and communication techniques effective, what are the advantages and disadvantages of team involvement in data gathering, analysis, and communication, and what is the best way to use video? Most participants believed involving design teams in data gathering as well as analysis, observing users in real time, developing the negotiation and social skills of usability practitioners, and the use of narrative as a representation of user-artifact interaction were all valuable approaches to the design and development of usable products. This article describes the activities and findings of the workshop participants in more detail.
Estimating alphanumeric selectivity in the presence of wildcards
Authors: P. Krishnan, Jeffrey Scott Vitter, Bala Iyer
Venue: ACM SIGMOD Record (1996)

Success of commercial query optimizers and database management systems (object-oriented or relational) depend on accurate cost estimation of various query reordering [BGI]. Estimating predicate selectivity, or the fraction of rows in a database that satisfy a selection predicate, is key to determining the optimal join order. Previous work has concentrated on estimating selectivity for numeric fields [ASW, HaSa, IoP, LNS, SAC, WVT]. With the popularity of textual data being stored in databases, it has become important to estimate selectivity accurately for alphanumeric fields. A particularly problematic predicate used against alphanumeric fields is the SQL like predicate [Dat]. Techniques used for estimating numeric selectivity are not suited for estimating alphanumeric selectivity.In this paper, we study for the first time the problem of estimating alphanumeric selectivity in the presence of wildcards. Based on the intuition that the model built by a data compressor on an input text encapsulates information about common substrings in the text, we develop a technique based on the suffix tree data structure to estimate alphanumeric selectivity. In a statistics generation pass over the database, we construct a compact suffix tree-based structure from the columns of the database. We then look at three families of methods that utilize this structure to estimate selectivity during query plan costing, when a query with predicates on alphanumeric attributes contains wildcards in the predicate.We evaluate our methods empirically in the context of the TPC-D benchmark. We study our methods experimentally against a variety of query patterns and identify five techniques that hold promise.
On testable multipliers for fixed-width data path architectures
Authors: Nilanjan Mukherjee, Janusz Rajski, Jerzy Tyszer
Venue: Proceedings of the 1995 IEEE/ACM international conference on Computer-aided design (1995)

The usage of multipliers in the increasingly demanding fixed-width data path architectures poses serious testability problems. Their truncated outputs not only degrade the fault observability, but the output responses of multipliers are inadequate to completely test functional blocks that are driven by them. In this paper, we propose a new design for testability scheme to improve the overall testability of data paths. The methodology takes into account the truncated least significant bits of the product in the test mode to increase the variety of patterns at the output of a multiplier. The proposed techniques are part of the Arithmetic Built-in Self Test methodology and can be incorporated with a minimal performance degradation and area overhead.
Type checking concurrent I/O
Authors: W. H. Carlisle
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1995)

In parallel programming languages multityped data structures may be shared by two or more processes. Process I/O to these structures is assumed to be physically interleaved but logically parallel. This article addresses a syntactic mechanism to specify a type for such structures and extends an example language and its type-checking algorithm to these structures.
An assessment of nonmonotone linesearch techniques for unconstrained optimization
Authors: Philippe L. Toint
Venue: SIAM Journal on Scientific Computing (1996)

The purpose of this paper is to discuss the potential of nonmonotone techniques for enforcing convergence of unconstrained minimization algorithms from starting points distant from the solution. Linesearch-based algorithms are considered for both small and large problems, and extensive numerical experiments show that this potential is sometimes considerable. A new variant is introduced in order to limit some of the identified drawbacks of the existing techniques. This variant is again numerically tested and appears to be competitive. Finally, the impact of preconditioning on the considered methods is examined.
An Evaluation of Intrinsic Dimensionality Estimators
Authors: Peter J. Verveer, Robert P. W. Duin
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

The intrinsic dimensionality of a data set may be useful for understanding the properties of classifiers applied to it and thereby for the selection of an optimal classifier.In this paper we compare the algorithms for two estimators of the intrinsic dimensionality of a given data set and extend their capabilities. One algorithm is based on the local eigenvalues of the covariance matrix in several small regions in the feature space. The other estimates the intrinsic dimensionality from the distribution of the distances from an arbitrary data vector to a selection of its neighbors.The characteristics of the two estimators are investigated and the results are compared. It is found that both can be applied successfully, but that they might fail in certain cases. The estimators are compared and illustrated using data generated from chromosome banding profiles.