ppxscal/embedding_network huggingface dataset:
A distributed memory LAPSE: parallel simulation of message-passing programs
Authors: Phillip M. Dickens, Philip Heidelberger, David M. Nicol
Venue: Proceedings of the eighth workshop on Parallel and distributed simulation (1994)

This paper describes a tool, LAPSE (Large Application Parallel Simulation Environment), that allows one to use a small number of parallel processors to simulate the behavior of a message-passing code running on a large number of processors, for the purposes of scalability studies and performance tuning. LAPSE is implemented on the Intel Paragon, and has achieved small slowdowns (relative to native code) and high speed-ups on large problems.
Automated learning of decision rules for text categorization
Authors: Chidanand Apté, Fred Damerau, Sholom M. Weiss
Venue: ACM Transactions on Information Systems (TOIS) (1994)

We describe the results of extensive experiments using optimized rule-based induction methods on large document collections. The goal of these methods is to discover automatically classification patterns that can be used for general document categorization or personalized filtering of free text. Previous reports indicate that human-engineered rule-based systems, requiring many man-years of developmental efforts, have been successfully built to &ldquo;read&rdquo; documents and assign topics to them. We show that machine-generated decision rules appear comparable to human performance, while using the identical rule-based representation. In comparison with other machine-learning techniques, results on a key benchmark from the Reuters collection show a large gain in performance, from a previously reported 67% recall/precision breakeven point to 80.5%. In the context of a very high-dimensional feature space, several methodological alternatives are examined, including universal versus local dictionaries, and binary versus frequency-related features.
Origin tracking
Authors: A. van Deursen, P. Klint, F. Tip
Venue: Journal of Symbolic Computation (1993)

We are interested in generating interactive programming environments from formal language specifications and use term rewriting to execute these specifications. Functions defined in a specification operate on the abstract syntax tree of programs and the initial term for the rewriting process will consist of an application of some function (e.g., a type checker, evaluator or translator) to the syntax tree of a program. During the term rewriting process, pieces of the program such as identifiers, expressions, or statements, recur in intermediate terms. We want to formalize these recurrences and use them, for example, for associating positional information with messages in error reports, visualizing program execution, and constructing language-specific debuggers. Origins are relations between subterms of intermediate terms and subterms of the initial term. Origin tracking is a method for incrementally computing origins during rewriting. We give a formal definition of origins, and present a method for implementing origin tracking.
The 3 R's of optimizing constraint logic programs: refinement, removal and reordering
Authors: Kimball G. Marriott, Peter J. Stuckey
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

Central to constraint logic programming (CLP) languages is the notion of a global constraint solver which is queried to direct execution and to which constraints are monotonically added. We present a methodology for use in the compilation of CLP languages which is designed to reduce the overhead of the global constraint solver. This methododology is based on three optimizations. The first, refinement, involves adding new constraints, which in effect make information available earlier in the computation, guiding subsequent execution away from unprofitable choices. The second, removal, involves eliminating constraints from the solver when they are redundant. The last, reordering, involves moving constraint addition later and constraint removal earlier in the computation. Determining the applicability of each optimization requires sophisticated global analysis. These analyses are based on abstract interpretation and provide information about potential and definite interaction between constraints.
An adaptive memory management protocol for Time Warp parallel simulation
Authors: Samir R. Das, Richard M. Fujimoto
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

It is widely believed that Time Warp is prone to two potential problems: an excessive amount of wasted, rolled back computation resulting from &ldquo;rollback thrashing&rdquo; behaviors, and inefficient use of memory, leading to poor performance of virtual memory and/or multiprocessor cache systems. An adaptive mechanism is proposed based on the Cancelback memory management protocol that dynamically controls the amount of memory used in the simulation in order to maximize performance. The proposed mechanism is adaptive in the sense that it monitors the execution of the Time Warp program, automatically adjusts the amount of memory used to reduce Time Warp overheads (fossil collection, Cancelback, the amount of rolled back computation, etc.) to a manageable level. The mechanism is based on a model that characterizes the behavior of Time Warp programs in terms of the flow of memory buffers among different buffer pools. We demonstrate that an implementation of the adaptive mechanism on a Kendall Square Research KSR-1 multiprocessor is effective in automatically maximizing performance while minimizing memory utilization of Time Warp programs, even for dynamically changing simulation models.
Partially preemptible hash joins
Authors: Hwee Hwa Pang, Michael J. Carey, Miron Livny
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

With the advent of real-time and goal-oriented database systems, priority scheduling is likely to be an important feature in future database management systems. A consequence of priority scheduling is that a transaction may lose its buffers to higher-priority transactions, and may be given additional memory when transactions leave the system. Due to their heavy reliance on main memory, hash joins are especially vulnerable to fluctuations in memory availability. Previous studies have proposed modifications to the hash join algorithm to cope with these fluctuations, but the proposed algorithms have not been extensively evaluated or compared with each other. This paper contains a performance study of these algorithms. In addition, we introduce a family of memory-adaptive hash join algorithms that turns out to offer even better solutions to the memory fluctuation problem that hash joins experience.
An example-based mapping method for text categorization and retrieval
Authors: Yiming Yang, Christopher G. Chute
Venue: ACM Transactions on Information Systems (TOIS) (1994)

A unified model for text categorization and text retrieval is introduced. We use a training set of manually categorized documents to learn word-category associations, and use these associations to predict the categories of arbitrary documents. Similarly, we use a training set of queries and their related documents to obtain empirical associations between query words and indexing terms of documents, and use these associations to predict the related documents of arbitrary queries. A Linear Least Squares Fit (LLSF) technique is employed to estimate the likelihood of these associations. Document collections from the MEDLINE database and Mayo patient records are used for studies on the effectiveness of our approach, and on how much the effectiveness depends on the choices of training data, indexing language, word-weighting scheme, and morphological canonicalization. Alternative methods are also tested on these data collections for comparison. It is evident that the LLSF approach uses the relevance information effectively within human decisions of categorization and retrieval, and achieves a semantic mapping of free texts to their representations in an indexing language. Such a semantic mapping lead to a significant improvement in categorization and retrieval, compared to alternative approaches.
A Rely and Guarantee Method for Timed CSP: A Specification and Design of a Telephone Exchange
Authors: Andrew Kay, Joy N. Reed
Venue: IEEE Transactions on Software Engineering (1993)

A rely and guarantee method for timed communicating sequential processes (TCPSs), by which the behavior of a component belonging to a composite system is specified in terms of what it guarantees to its neighbors and what it relies on from them, is described. The method is illustrated using an overview of the specification of a plain old telephone service together with part of a design that provably satisfies this specification. The specification and design deal with safety, liveness, and troublesome race conditions.
Towards an automated tupling strategy
Authors: Wei-Ngan Chin
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

The tupling transformation strategy can be used to merge loops together by combining recursive calls and also to eliminate redundant calls for a class of programs. The clever (and difficult) step of this transformation strategy is to find an appropriate tuple of calls, called the eureka tuple, which would allow each set of calls to be computed recursively from its previous set. In many cases, this transformation can produce super-linear speedup. In this paper, we present an analysis method which could find eureka tuples for a wide range of functional programs. Our work extends that of a number of past techniques which have used dependency graphs of function calls for analysing redundancy patterns. Our main contribution is the use of appropriate call orderings based on recursion parameters to systematically search for eureka tuples in dependency graphs. They allow us to construct sequences of tuples, called the continuous sequences of tuples, whereby the existence of a matched pair of tuples in the sequence corresponds to a suitable eureka tuple. An extension of the basic analysis method which uses trees, instead of sequences, of tuples will also be presented. The basic and extended analysis methods will be shown to be applicable to a wide range of programs. They can be guaranteed to terminate by either bounding the search or by applying suitable restrictions on the class of applicable programs. The latter approach yields a safe automated procedure for tupling transformation.
Data locality and load balancing in COOL
Authors: Rohit Chandra, Anoop Gupta, John L. Hennessy
Venue: ACM SIGPLAN Notices (1993)

Large-scale shared memory multiprocessors typically support a multilevel memory hierarchy consisting of per-processor caches, a local portion of shared memory, and remote shared memory. On such machines, the performance of parallel programs is often limited by the high latency of remote memory references. In this paper we explore how knowledge of the underlying memory hierarchy can be used to schedule computation and distribute data structures, and thereby improve data locality. Our study is done in the context of COOL, a concurrent object-oriented language developed at Stanford. We develop abstractions for the programmer to supply optional information about the data reference patterns of the program. This information is used by the runtime system to distribute tasks and objects so that the tasks execute close (in the memory hierarchy) to the objects they reference. We demonstrate the effectiveness of these techniques by applying them to several applications chosen from the SPLASH parallel benchmark suite. Our experience suggests that improving data locality can be simple through a combination of programmer abstractions and smart runtime scheduling.
Direct proof of a theorem by Kalkbrener, Sweedler, and Taylor
Authors: Erich Kaltofen
Venue: ACM SIGSAM Bulletin (1993)

For given f1,..., fm isin; K[x] that are relatively prime, where K is a field, Kalkbrener, Sweedler, and Taylor (1993) present degree bounds on the ai needed to express 1 (and other low degree polynomials) as Sigma;aifi. Their bounds are an improvement on bounds given by Kaki eacute; (1976). This note presents a direct proof of the following fact.
Implementation of the CORAL deductive database system
Authors: Raghu Ramakrishnan, Divesh Srivastava, S. Sudarshan, Praveen Seshadri
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

CORAL is a deductive database system that supports a rich declarative language, provides a wide range of evaluation methods, and allows a combination of declarative and imperative programming. The data can be persistent on disk or can reside in main-memory. We describe the architecture and implementation of CORAL. There were two important goals in the design of the CORAL architecture: (1) to integrate the different evaluation strategies in a reasonable fashion, and (2) to allow users to influence the optimization techniques used so as to exploit the full power of the CORAL implementation. A CORAL declarative program can be organized as a collection of interacting modules and this modular structure is the key to satisfying both these goals. The high level module interface allows modules with different evaluation techniques to interact in a transparent fashion. Further, users can optionally tailor the execution of a program by selecting from among a wide range of control choices at the level of each module. CORAL also has an interface with C++, and users can program in a combination of declarative CORAL, and C++ extended with CORAL primitives. A high degree of extensibility is provided by allowing C++ programmers to use the class structure of C++ to enhance the CORAL implementation.
The dimensions and correlates of systems development quality
Authors: T. Ravichandran, Arun Rai
Venue: Proceedings of the 1994 computer personnel research conference on Reinventing IS : managing information technology in changing organizations: managing information technology in changing organizations (1994)

The need to improve systems development quality is increasingly felt by information systems departments in organizations. A clear definition of systems development quality is required to focus quality management efforts. We develop a broader definition of quality by identifying product and process dimensions of quality that systems development should ensure, and present a framework to classify systems development quality metrics.We then go on to develop, a theoretical model to explain the correlates of systems development quality, by integrating related research in the areas of total quality management, systems development, management of the IS function, and IS implementation. Five factors (top management support, development methodology characteristics, project management characteristics, task structure of IS teams and control structure of IS teams) were identified. Implications for theory, future research and practice are discussed.
Facilitation issues in distributed group support systems
Authors: Fred Niederman, Catherine M. Beise, Peggy M. Beranek
Venue: Proceedings of the 1993 conference on Computer personnel research (1993)

Local area networks and related computer and communication technologies are opening up new possibilities for performing group tasks in organizations. This paper provides background on the evolving use of information technology to support distributed group meetings. It identifies facilitation as a key factor in the success of group meetings. Thirty-four professional facilitators of face-to-face meetings are interviewed regarding the impacts of a distributed setting on meetings. Opinions regarding distributed meetings include concerns for group process and task accomplishment, observations of changes in the role of the facilitator, and potential impacts on how the organization functions. Concerns regarding the design of specific technologies for implementing distributed meetings are also identified.
Algorithm 718: A FORTRAN subroutine to solve the eigenvalue allocation problem for single-input systems
Authors: George Miminis, Michael Reid
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

An efficient implementation of an algorithm for the eigenvalue allocation (pole placement) problem of single-input linear systems using state feedback is given in this paper. The implementation uses the BLAS level-1 [2] subroutines when possible for better performance. A brief description of the algorithm along with some computational details is also given.
Groundness analysis for Prolog: implementation and evaluation of domain prop
Authors: Baudouin Le Charlier, Pascal van Hentenryck
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

The domain Prop [22,8] is a conceptually simple and elegant abstract domain to compute groundness information for Prolog programs. In particular, abstract substitutions are represented by Boolean functions built using the logical connectives &hArr;,&or;,&and; . Prop has raised much theoretical interest recently but little is known about the practical accuracy and efficiency of this domain. In this paper, we describe an implementation of Prop and we use it to instantiate a generic abstract interpretation algorithm [14, 10, 17, 15]. A key feature of the implementation is the use of ordered binary decision graphs. The implementation has been compared systematically to two other abstract domains, Mode and Pattern, from the point of view of groundness analysis. The experimental results indicate that (1)Prop is very accurate to infer groundness information; (2) this domain is quite practical in terms of efficiency, although it is theoretically exponential (in the number of clause variables).
Types for the language designer (abstract)
Authors: Michael Schwartzbach, Jens Palsberg
Venue: ACM SIGPLAN OOPS Messenger (1993)

Types for the Language Designer Michael Schwartzbach Jens Palsberg, Aarhus University, Denmark>/p> The type systems of object-oriented languages have specific goals: they serve as partial documentation, they provide modularity, and they ensure safety and efficiency at run-time. There are many choices in the design of a type system, and it is hard to evaluate their tradeoffs. This tutorial teaches a coherent theory of type systems for object-oriented languages that can be used for both explicit systems (where the programmer supplies type annotations) and implicit systems (where the compiler must perform type inference), and forty systems based on interfaces, classes, and sets of classes. The tutorial defines an idealized object-oriented language, inspired by Smalltalk, and develops several type systems for it. This uniform framework makes it easy to compare different approaches. The tutorial explores the limitations of static type checking and shows how dynamic type checking can be introduced. It demonstrates how subclassing is different from subtyping, how specification types differ from implementation types, and the influence of a type system on separate compilation.
Partial evaluation of general parsers
Authors: Christian Mossin
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

Applications of partial evaluation have so far mainly focused on generation of compilers from interpreters for programming languages. We partially evaluate a simple general LR(k) parsing algorithm. To obtain good results, we rewrite the algorithm using a number of binding-time improvements. The final LR(1) parser has been specialized using Similix, a partial evaluator for a higher order subset of Scheme [3]. The obtained specialized parsers are efficient and compact. Partial evaluation is responsible for the (equivalent of) the sets-of-items construction, and the construction of parsing tables. This paper is an extended abstract of [14].
Parallel logic simulation of VLSI systems
Authors: Mary L. Bailey, Jack V. Briner,  Jr., Roger D. Chamberlain
Venue: ACM Computing Surveys (CSUR) (1994)

Fast, efficient logic simulators are an essential tool in modern VLSI system design. Logic simulation is used extensively for design verification prior to fabrication, and as VLSI systems grow in size, the execution time required by simulation is becoming more and more significant. Faster logic simulators will have an appreciable economic impact, speeding time to market while ensuring more thorough system design testing. One approach to this problem is to utilize parallel processing, taking advantage of the concurrency available in the VLSI system to accelerate the logic simulation task.Parallel logic simulation has received a great deal of attention over the past several years, but this work has not yet resulted in effective, high-performance simulators being available to VLSI designers. A number of techniques have been developed to investigate performance issues: formal models, performance modeling, empirical studies, and prototype implementations. Analyzing reported results of these techniques, we conclude that five major factors affect performance: synchronization algorithm, circuit structure, timing granularity, target architecture, and partitioning. After reviewing techniques for parallel simulation, we consider each of these factors using results reported in the literature. Finally we synthesize the results and present directions for future research in the field.
Employment structures of information systems professionals: a comparative study of the United States and Singapore
Authors: Sandra Slaughter, Soon Ang
Venue: Proceedings of the 1994 computer personnel research conference on Reinventing IS : managing information technology in changing organizations: managing information technology in changing organizations (1994)

Prior research into information systems (IS) personnel has been primarily directed from the perspective of an internal labor market. The assumption underlying that body of research is that agents, i.e., IS workers, form long-term employment relationships with the principals, i.e., the firms employing. However, the recent emphasis on externalizing IS labor (for example, by outsourcing) suggests that this assumption may no longer hold true. This study provides an empirical investigation of the extent of externalizing IS workers in both the United States and Singapore. Results indicate that the United States utilizes more externalized IS employment structures than Singapore. Moreover, the trend toward externalized IS workers is more pronounced in the United States in the most recent three quarters analyzed than at any other period in the 1990&ndash;1993 timeframe. Possible explanations for the differential trend behavior ensue.