ppxscal/embedding_network huggingface dataset:
Description of a high capacity, fast turnaround university computing center
Authors: W. C. Lynch
Venue: Communications of the ACM (1966)

The operating system for the UNIVAC 1107 at Case Institute is reviewed. The system is of interest because of the low turn-around times achieved, the high throughput achieved and the lack of an operating staff. Turnaround times below 5 minutes and job volume above 75,000 per quarter year are reported.
Robust algorithms for restricted domains
Authors: Vijay Raghavan, Jeremy Spinrad
Venue: Proceedings of the twelfth annual ACM-SIAM symposium on Discrete algorithms (2001)

We introduce a new definition of efficient algorithms for restricted domains. Under this definition, an algorithm is required to be &ldquo;robust,&rdquo; i.e., it must produce correct output regardless of whether the input actually belongs to the restricted domain or not. This is to be contrasted with the &ldquo;promise&rdquo; version of solving problems on restricted domains, in which there is a guarantee that the input is in the class, and an algorithm to &ldquo;solve&rdquo; the problem need not function correctly or even terminate if this guarantee is not met. The more stringent requirement of robustness in algorithms gives an important benefit: such algorithms are amenable to manipulation as building blocks of more general algorithms; in other words, composition of robust algorithms preserves robustness. In contrast, promise algorithms cannot be so composed. There exist problems which have a polynomial time promise solution, while being NP-hard if required to be robust. We show the perhaps surprising result that finding a maximum independent set in a well-covered graph (i.e., a graph in which every maximal independent set is of the same size) is NP-hard. An argument can be made that this hardness result is more meaningful than the trivial polynomial time promise algorithm. Graph classes provide interesting natural restricted domains; there are many problems which are efficiently solvable given a special and natural representation of a graph (i.e., a &ldquo;model&rdquo;), but which are open with respect to time complexity if the graph is given in a general form such as an adjacency list or an adjacency matrix. One such open problem is that of finding a maximum clique in unit disk graphs here, we give a polynomial time robust algorithm for this problem, i.e., given an input graph G in general form, the output is either a maximum clique for G or a certificate that G is not a unit disk graph. The existence of this algorithm is to be reconciled with the apparent contradiction posed by the facts: Recognizing whether an input graph given in general form is a unit disk graph is NP-hard; in fact, it is not even known to be in NP. Finding a maximum clique in an input graph given in general form is NP-hard.
Using a PDP-11/10 to teach content and history in computer organization courses
Authors: Douglas Harms, Dave Berque
Venue: ACM SIGCSE Bulletin (2001)

This paper describes our use of a 1970's era PDP-11/10 to support an hour long module which we have incorporated into our computer organization course for the past few semesters. The module is designed to reinforce standard concepts such as number systems and two-pass assemblers while at the same time exposing the students to some historical issues. After providing some background information about the PDP-11/10 we explain the motivation for our approach. Then we describe a fifteen minute instructional video which we have produced on the topic of developing programs on the PDP/11-10. The video is available from the authors either on VHS tape or as a QuickTime file, thereby allowing instructors at other schools to try our approach by showing the video to their students.
Multiscale Linear Solvers for Very Large Systems Derived from PDES
Authors: Klaus Lackner, Ralph Menikoff
Venue: SIAM Journal on Scientific Computing (1999)

We present a novel linear solver that works well for large systems obtained from discretizing PDEs. It is robust and, for the examples we studied, the computational effort scales linearly with the number of equations. The algorithm is based on a wavelength decomposition that combines conjugate gradient, multiscaling, and iterative splitting methods into a single approach. On the surface, the algorithm is a simple preconditioned conjugate gradient with all the sophistication of the algorithm in the choice of the preconditioning matrix. The preconditioner is a very good approximate inverse of the linear operator. It is constructed from the inverse of the coarse grained linear operator and from smoothing operators that are based on an operator splitting on the fine grid. The coarse graining captures the long wavelength behavior of the inverse operator, while the smoothing operator captures the short wavelength behavior. The conjugate gradient iteration accounts for the coupling between long and short wavelengths. The coarse grained operator corresponds to a lower resolution approximation to the PDEs. While the coarse grained inverse is not known explicitly, the algorithm requires only that the preconditioner can be a applied to a vector. The coarse inverse applied to a vector can be obtained as the solution of another preconditioned conjugate gradient solver that applies the same algorithm to the smaller problem. Thus, the method is naturally recursive. The recursion ends when the matrix is sufficiently small for a solution to be obtained efficiently with a standard solver. The local feedback provided by the conjugate gradient step at every level makes the algorithm very robust. In spite of the effort required for the coarse inverse, the algorithm is efficient because the increased quality of the approximate inverse greatly reduces the number of times the preconditioner needs to be evaluated. A feature of the algorithm is that the transition between coarse grids is determined dynamically by the accuracy requirement of the conjugate gradient solver at each level. Typically, later iterations on the finer scales need fewer iterations on the coarser scales and the computational effort is proportional to N rather than N log N, where N is the number of equations. We have tested our solver on the porous flow equation. On a workstation we have solved problems on grids ranging in dimension over three orders of magnitude, from 103 to 106, and found that the linear scaling holds. The algorithm works well, even when the permeability tensor has spatial variations exceeding a factor of 109.
Phase Clocks for Transient Fault Repair
Authors: Ted Herman
Venue: IEEE Transactions on Parallel and Distributed Systems (2000)

Phase clocks are synchronization tools that implement a form of logical time in distributed systems. For systems tolerating transient faults by self-repair of damaged data, phase clocks can enable reasoning about the progress of distributed repair procedures. This paper presents a phase clock algorithm suited to the model of transient memory faults in asynchronous systems with read/write registers. The algorithm is self-stabilizing and guarantees accuracy of phase clocks within $O(k)$ time following an initial state that is k-faulty. Composition theorems show how the algorithm can be used for the timing of distributed procedures that repair system outputs.
Early experience with Mesa
Authors: Charles M. Geschke, James H. Morris,  Jr., Edwin H. Satterthwaite
Venue: Communications of the ACM (1977)

The experiences of Mesa's first users&mdash;primarily its implementers&mdash;are discussed, and some implications for Mesa and similar programming languages are suggested. The specific topics addressed are: module structure and its use in defining abstractions, data-structuring facilities in Mesa, an equivalence algorithm for types and type coercions, the benefits of the type system and why it is breached occasionally, and the difficulty of making the treatment of variant records safe.
Stable algorithms for link analysis
Authors: Andrew Y. Ng, Alice X. Zheng, Michael I. Jordan
Venue: Proceedings of the 24th annual international ACM SIGIR conference on Research and development in information retrieval (2001)

The Kleinberg HITS and the Google PageRank algorithms are eigenvector methods for identifying ``authoritative'' or ``influential'' articles, given hyperlink or citation information. That such algorithms should give reliable or consistent answers is surely a desideratum, and in~\cite{ijcaiPaper}, we analyzed when they can be expected to give stable rankings under small perturbations to the linkage patterns. In this paper, we extend the analysis and show how it gives insight into ways of designing stable link analysis methods. This in turn motivates two new algorithms, whose performance we study empirically using citation data and web hyperlink data.
Pseudoinversus and conjugate gradients
Authors: Magnus R. Hestenes
Venue: Communications of the ACM (1975)

This paper is devoted to the study of connections between pseudoinverses of matrices and conjugate gradients and conjugate direction routines.
The diameter of random massive graphs
Authors: Linyuan Lu
Venue: Proceedings of the twelfth annual ACM-SIAM symposium on Discrete algorithms (2001)

Many massive graphs (such as the WWW graph and Call graphs) share certain universal characteristics which can be described by so-called the &ldquo;power law&rdquo;. Here we determine the diameter of random power law graphs up to a constant factor for almost all ranges of parameters. These results show a strong evidence that the diameters of most massive graphs are about logarithm of their sizes up to a constant factor.
IT services: costs, metrics, benchmarking, marketing
Authors: Anthony E. Tardugno, Thomas R. DiPasquale, Robert E. Matthews
Venue:  (2000)

Unleashing the Power of Integrated Service DeliveryHarris Kern's Enterprise Computing Institute Solutions for IT ProfessionalsDelighting IT customers: the real-world, start-to-finish guideIT Services is the first 100% customer-focused guide to satisfying the consumers of your company's IT services - and building the loyalty your IT organization needs. In this book, three leading IT professionals present a fully integrated, comprehensive approach to service delivery in today's global, distributed environments.You'll discover how to establish processes, service and cost models, performance measurements, and "stretch" goals that achieve clear business benefits-and then transform those goals into reality. Proven results, benchmarks, and case studies - not just theory! Linking goal-setting, process development, and metrics to the goals of the enterprise - step-by-step Gaining buy-in from management, internal customers, and external suppliers Building stable, predictable and cost-effective application support infrastructures Structuring support services for maximum effectivenessApplicable to both in-house and outsourced operations, IT Services offers a total roadmap for executives building enterprise-wide operations centers; practical help for managers seeking to deliver cost-effective support; and invaluable insight for IT "customers" who need to know what they can expect from their technology professionals.
A novel renaming mechanism that boosts software prefetching
Authors: Daniel Ortega, Mateo Valero, Eduard Ayguadé
Venue: Proceedings of the 15th international conference on Supercomputing (2001)

The detection and correct handling of data and control dependencies constitutes one of the biggest issues to expose ILP in current architectures. The ever increasing memory latencies and working space of programmes are making prefetching techniques crucial for the attainment of sustained high performance. Software prefetching allows the compiler to use information discovered at compile-time to effectively bring needed data before it is used, thus hiding all or part of the latency from main memory. On the other hand, renaming is a technique that allows the hardware to break register naming dependencies, thus exposing more parallelism to the hardware. In this paper we will present a new compiler-directed renaming mechanism focused on prefetch instructions. The compiler informs the hardware on the association of prefetch and load instructions, thus making it possible for the hardware to convert non-binding prefetches in to binding prefetches, without any of the compile-time limitations this other kind of prefetching may have. The mechanism can be implemented at a very low costin terms of area and we believe it will not impact cycle time. The research presented in this paper is at a first stage; nevertheless, our results for a set of numerical application show a speedup of 5% to 22%, and in any case no performance degradation was observed.
Organizing matrices and matrix operations for paged memory systems
Authors: A. C. McKellar, E. G. Coffman,  Jr.
Venue: Communications of the ACM (1969)

Matrix representations and operations are examined for the purpose of minimizing the page faulting occurring in a paged memory system. It is shown that carefully designed matrix algorithms can lead to enormous savings in the number of page faults occurring when only a small part of the total matrix can be in main memory at one time. Examination of addition, multiplication, and inversion algorithms shows that a partitioned matrix representation (i.e. one submatrix or partition per page) in most cases induced fewer page faults than a row-by-row representation. The number of page-pulls required by these matrix manipulation algorithms is also studied as a function of the number of pages of main memory available to the algorithm.
Experiments with list ranking for explicit multi-threaded (XMT) instruction parallelism
Authors: Dascal Vishkin, Uzi Vishkin
Venue: Journal of Experimental Algorithmics (JEA) (2000)

Algorithms for the problem of list ranking are empirically studied with respect to the Explicit Multi-Threaded (XMT) platform for instruction-level parallelism (ILP). The main goal of this study is to understand the differences between XMT and more traditional parallel computing implementation platforms/models as they pertain to the well studied list ranking problem. The main two findings are: (i) good speedups for much smaller inputs are possible and (ii) in part, the first finding is based on a new variant of a 1984 algorithm, called the No-Cut algorithm. The paper incorporates analytic (non-asymptotic) performance analysis into experimental performance analysis for relatively small inputs. This provides an interesting example where experimental research and theoretical analysis complement one another. Explicit Multi-Threading (XMT) is a fine-grained computation framework introduced in our SPAA'98 paper. Building on some key ideas of parallel computing, XMT covers the spectrum from algorithms through architecture to implementation; the main implementation related innovation in XMT was through the incorporation of low-overhead hardware and software mechanisms (for more effective fine-grained parallelism). The reader is referred to that paper for detail on these mechanisms. The XMT platform aims at faster single-task completion time by way of ILP.
Communicating sequential processes
Authors: C. A. R. Hoare
Venue: Communications of the ACM (1978)

This paper suggests that input and output are basic primitives of programming and that parallel composition of communicating sequential processes is a fundamental program structuring method. When combined with a development of Dijkstra's guarded command, these concepts are surprisingly versatile. Their use is illustrated by sample solutions of a variety of a familiar programming exercises.
Minimizing stall time in single and parallel disk systems
Authors: Susanne Albers, Naveen Garg, Stefano Leonardi
Venue: Journal of the ACM (JACM) (2000)

We study integrated prefetching and caching problems following the work of Cao et al. [1995] and Kimbrel and Karlin [1996]. Cao et al. and Kimbrel and Karlin gave approximation algorithms for minimizing the total elapsed time in single and parallel disk settings. The total elapsed time is the sum of the processor stall times and the length of the request sequence to be served.We show that an optimum prefetching/caching schedule for a single disk problem can be computed in polynomial time, thereby settling an open question by Kimbrel and Karlin. For the parallel disk problem, we give an approximation algorithm for minimizing stall time. The solution uses a few extra memory blocks in cache. Stall time is an important and harder to approximate measure for this problem. All of our algorithms are based on a new approach which involves formulating the prefetching/caching problems as linear programs.
How communication can improve the performance of multi-agent systems
Authors: Kam-Chuen Jim, C. Lee Giles
Venue: Proceedings of the fifth international conference on Autonomous agents (2001)

We analyze a general model of multi-agent communication in which all agents learn to communicate simultaneously to a message board. We show that the communicating multi-agent system is equivalent to a Mealy finite state machine whose states are determined by the agents' usage of the learned language. Increasing the language size increases the number of possible states in the Mealy machine, and can improve the performance of the multi-agent system. We introduce the term {\em semantic density} to describe the average number of meanings assigned to each word of a language. Using semantic density, a simple rule is presented that provides a pessimistic estimate of the minimum language size that should be used for any multi-agent problem in which the agents communicate simultaneously. Simulations on a version of the predator-prey pursuit problem, a simplified version of problems seen in warfare scenarios, validate these predictions. The communicating predators evolved using a genetic algorithm perform significantly better than all previous work on similar preys.
Algorithms for facility location problems with outliers
Authors: Moses Charikar, Samir Khuller, David M. Mount, Giri Narasimhan
Venue: Proceedings of the twelfth annual ACM-SIAM symposium on Discrete algorithms (2001)

Facility location problems are traditionally investigated with the assumption that all the clients are to be provided service. A significant shortcoming of this formulation is that a few very distant clients, called outliers, can exert a disproportionately strong influence over the final solution. In this paper we explore a generalization of various facility location problems (K-center, K-median, uncapacitated facility location etc) to the case when only a specified fraction of the customers are to be served. What makes the problems harder is that we have to also select the subset that should get service. We provide generalizations of various approximation algorithms to deal with this added constraint.
A virtual media (Vmedia)JPEG 2000 interactive image browser
Authors: Jin Li, Hong-Hui Sun
Venue: Proceedings of the eighth ACM international conference on Multimedia (2000)

A Vmedia JPEG 2000 interactive image browser is developed. Two key technologies make our system unique: it is the first to implement the decoder ROI access functionality of JPEG 2000, and it uses virtual media (Vmedia) protocol to manage and deliver the ROI bitstream in an efficient fashion. The user browses the image by specifying a region of interest (ROI) with spatial and resolution restriction. Only the portion of the compressed bitstream covering the current ROI is streamed. Moreover, the streaming is performed in a progressive fashion so that a coarse view of the ROI can be rendered very quickly and then gradually refined as more and more bits arrive. Vmedia greatly improves the browsing experience of large images over the slow network.
Numerical Accuracy of Fast Fourier Transforms with CORDIC Arithmetic
Authors: M. Bekooij, J. Huisken, K. Nowak
Venue: Journal of VLSI Signal Processing Systems (2000)

The vector rotation operation in the butterfly of a Fast Fourier Transform (FFT) can be calculated by a complex multiplier as well as a CORDIC (COordinate Rotation DIgital Computer). For these vector rotation blocks, expressions for the maximum numerical error are derived. It is shown that the error introduced by the CORDIC can be reduced by increasing the size of the input vector of the CORDIC and decreasing the size of the output vector by the same amount. This input vector scaling makes the reduction possible of the number of bits in the data path of the CORDIC. The impact on the Signal to Noise Ratio (SNR) of the FFT is evaluated when a CORDIC is applied in the FFT butterfly.
An automatic data acquisition and inquiry system using disk files
Authors: James D. Edwards
Venue: Communications of the ACM (1963)

Lockheed Missiles and Space Company has installed a large-scale Automatic Data Acquisition (ADA) system which ties together the Company's manufacturing facilities located in Van Nuys and Sunnyvale, California. The system includes over 200 Remote Input Stations which collect and transmit Company operating data to a central Data Processing Center. Two RCA 301 EDP Systems are used to record and control the flow of data transmitted to the Data Processing Center. A large capacity RCA 366 Data Disc File is used to store information required to provide up-to-date information in response to inquiries received from remotely located Inquiry Stations. In addition to storage of data on the disk files, the system automatically records all incoming and outgoing data on magnetic tape to be used as input to the Company's conventional off-line business data processing applications. The ACM Portal is published by the Association for Computing Machinery. Copyright © 2010 ACM, Inc. Terms of Usage Privacy Policy Code of Ethics Contact Us Useful downloads: Adobe Acrobat QuickTime Windows Media Player Real Player
Code size minimization and retargetable assembly for custom EPIC and VLIW instruction formats
Authors: Shail Aditya, Scott A. Mahlke, B. Ramakrishna Rau
Venue: ACM Transactions on Design Automation of Electronic Systems (TODAES) (2000)

PICO is a fully automated system for designing the architecture and the microarchitecture of VLIW and EPIC processors. A serious concern with this class of processors, due to their very long instructions, is their code size. One focus of this paper is to describe a series of code size minimization techniques used within PICO, some of which are applied during the automatic design of the instruction format, while others are applied during program assembly. The design of a retargetable assembler to support these techniques also poses certain novel challenges, which constitute the second focus of this paper. Contrary to widely held perceptions, we demonstrate that it is entirely possible to design VLIW and EPIC processors that are capable of issuing large numbers of operational per cycle, but whose code size is only moderately larger than that for a sequential CISC processor.
Processing object-oientation-based direction queries: a summary of results
Authors: Xuan Liu, Shashi Shekhar, Sanjay Chawla
Venue: Proceedings of the 8th ACM international symposium on Advances in geographic information systems (2000)

Direction based spatial relationships are critical in many domains including geographic information systems(GIS) and image interpretation. They are also frequently used as selection conditions in spatial queries. In this paper, we explore the processing of queries based on object-orientation-based directional relationships. A new open shape based strategy(OSS) is proposed. OSS converts the processing of the direction predicates to the processing of topological operations between open shapes and closed geometry objects. Since OSS models the direction region as an OpenShape, it does not need to know the boundary of the embedding world, and also eliminating the computation related to the world boundary. The experimental evaluations show that OSS consistently outperforms classical range query strategy both in I/O and CPU cost. This paper is a summary of the results.