ppxscal/embedding_network huggingface dataset:
An algorithm for minimally latent global virtual time
Authors: Alexander I. Tomlinson, Vijay K. Garg
Venue: ACM SIGSIM Simulation Digest (1993)

Global virtual time (GVT) is used in distributed simulations to reclaim memory, commit output, detect termination, and handle errors. It is a global function that is computed many times during the course of a simulation. A small GVT latency (delay between its occurrence and detection) allows for more efficient use of resources. We present an algorithm which minimizes the latency, and we prove its correctness. The algorithm is unique in that a target virtual time (TVT) is predetermined by an initiator who then detects when GVT &ge; TVT. This approach eliminates the avalanche effect because the collection phase is spread out over time, and it allows for regular and timely GVT updates. The algorithm does not require messages to be acknowledged, which significantly reduces the message overhead of the simulation. One possible application is with interactive simulators, where regular and timely updates would produce output that is up to date and appears smooth.
Characteristics of files in NFS environments
Authors: J. Michael Bennett, Michael A. Bauer, David Kinchlea
Venue: ACM SIGSMALL/PC Notes (1992)

As local area networks of workstations and file servers grow, the management of user and system files becomes increasingly more challenging for system administrators. In order to develop effective management tools for these administrators, the nature of files in workstation environments must be understood. This paper presents a static analysis of file usage patterns of a typical workstation environment using a standard client-server paradigm (NFS). The data reveals some differences in characteristics for files in networked environments compared with files in timesharing systems. The study also suggests what data and techniques might be appropriate as a basis for a management tool for network administrators. The paper concludes with a recommendation for the construction of a real-time management and data gathering tool that may give early-warnings of server overload or may be useful in exploring trade-offs among file allocation strategies.
Multistrategy Learning and Theory Revision
Authors: Lorenza Saitta, Marco Botta, Filippo Neri
Venue: Machine Learning (1993)

This article presents the system WHY, which learns and updates a diagnostic knowledge base using domain knowledge and a set of examples. The a priori knowledge consists of a causal model of the domain that states the relationships among basic phenomena, and a body of phenomenological theory that describes the links between abstract concepts and their possible manifestations in the world. The phenomenological knowledge is used deductively, the causal model is used abductively, and the examples are used inductively. The problems of imperfection and intractability of the theory are handled by allowing the system to make assumptions during its reasoning. In this way, robust knowledge can be learned with limited complexity and a small number of examples. The system works in a first-order logic environment and has been applied in a real domain.
Sentinel scheduling: a model for compiler-controlled speculative execution
Authors: Scott A. Mahlke, William Y. Chen, Roger A. Bringmann, Richard E. Hank, Wen-Mei W. Hwu, B. Ramakrishna Rau, Michael S. Schlansker
Venue: ACM Transactions on Computer Systems (TOCS) (1993)

Speculative execution is an important source of parallelism for VLIW and superscalar processors. A serious challenge with compiler-controlled speculative execution is to efficiently handle exceptions for speculative instructions. In this article, a set of architectural features and compile-time scheduling support collectively referred to as sentinel scheduling is introduced. Sentinel scheduling provides an effective framework for both compiler-controlled speculative execution and exception handling. All program exceptions are accurately detected and reported in a timely manner with sentinel scheduling. Recovery from exceptions is also ensured with the model. Experimental results show the effectiveness of sentinel scheduling for exploiting instruction-level parallelism and overhead associated with exception handling.
Global synchronization for optimistic parallel discrete event simulation
Authors: David M. Nicol
Venue: ACM SIGSIM Simulation Digest (1993)

A number of optimistic synchronization schemes for parallel simulation rely upon a global synchronization. The problem is to determine when every processor has completed all its work, and there are no messages in transit in the system that will cause more work. Most previous solutions to the problem have used distributed termination algorithms, which are inherently serial; other parallel mechanisms may be inefficient. In this paper we describe an efficient parallel algorithm derived from a common &ldquo;barrier&rdquo; synchronization algorithm used in parallel processing. The algorithm's principal attraction is speed, and generality&mdash;it is designed to be used in contexts more general than parallel discrete-event simulation. To establish our claim to speed, we compare our algorithm's performance with the standard barrier algorithm, and find that its additional costs are not excessive. Our experiments are conducted using up to 256 processors on the Intel Touchstone Delta.
Redundancy reduction as a strategy for unsupervised learning
Authors: A. Norman Redlich
Venue: Neural Computation (1993)

A redundancy reduction strategy, which can be applied in stages, is proposed as a way to learn as efficiently as possible the statistical properties of an ensemble of sensory messages. The method works best for inputs consisting of strongly correlated groups, that is features, with weaker statistical dependence between different features. This is the case for localized objects in an image or for words in a text. A local feature measure determining how much a single feature reduces the total redundancy is derived which turns out to depend only on the probability of the feature and of its components, but not on the statistical properties of any other features. The locality of this measure makes it ideal as the basis for a "neural" implementation of redundancy reduction, and an example of a very simple non-Hebbian algorithm is given. The effect of noise on learning redundancy is also discussed.
Array privatization for shared and distributed memory machines (extended abstract)
Authors: Peng Tu, David Padua
Venue: ACM SIGPLAN Notices (1993)

Memory related anti- and output-dependences can limit the potential parallelism in ordinary programs. In a distributed memory system, improper partition and distribution of data involved in memory related dependences may incur unnecessary communications and load imbalance. In this extended abstract, we present an overview of our work on using array privatization to enhance inherent parallelism and reduce communications.
Type reconstruction for variable-arity procedures
Authors: Hsianlin Dzeng, Christopher T. Haynes
Venue: ACM SIGPLAN Lisp Pointers (1994)

An ML-style type system with variable-arity procedures is defined that supports both optional arguments and arbitrarily-long argument sequences. A language with variable-arity procedures is encoded in a core-ML variant with infinitary tuples. We present an algebra of infinitary tuples and solve its unification problem. The resulting type discipline preserves principal typings and has a terminating type reconstruction algorithm. The expressive power of infinitary tuples is illustrated.
Higher-order interpolation and least-squares approximation using implicit algebraic surfaces
Authors: Chandrajit Bajaj, Insung Ihm, Joe Warren
Venue: ACM Transactions on Graphics (TOG) (1993)

In this article, we characterize the solution space of low-degree, implicitly defined, algebraic surfaces which interpolate and/or least-squares approximate a collection of scattered point and curve data in three-dimensional space. The problem of higher-order interpolation and least-squares approximation with algebraic surfaces under a proper normalization reduces to a quadratic minimization problem with elegant and easily expressible solutions. We have implemented our algebraic surface-fitting algorithms, and included them in the distributed and collaborative geometric environment SHASTRA. Several examples are given to illustrate how our algorithms are applied to algebraic surface design.
A modeling study of the TPC-C benchmark
Authors: Scott T. Leutenegger, Daniel Dias
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

The TPC-C benchmark is a new benchmark approved by the TPC council intended for comparing database platforms running a medium complexity transaction processing workload. Some key aspects in which this new benchmark differs from the TPC-A benchmark are in having several transaction types, some of which are more complex than that in TPC-A, and in having data access skew. In this paper we present results from a modelling study of the TPC-C benchmark for both single node and distributed database management systems. We simulate the TPC-C workload to determine expected buffer miss rates assuming an LRU buffer management policy. These miss rates are then used as inputs to a throughput model. From these models we show the following: (i) We quantify the data access skew as specified in the benchmark and show what fraction of the accesses go to what fraction of the data. (ii) We quantify the resulting buffer hit ratios for each relation as a function of buffer size. (iii) We show that close to linear scale-up (about 3% from the ideal) can be achieved in a distributed system, assuming replication of a read-only table. (iv) We examine the effect of packing hot tuples into pages and show that significant price/performance benefit can be thus achieved. (v) Finally, by coupling the buffer simulations with the throughput model, we examine typical disk/memory configurations that maximize the overall price/performance.
Information systems security design methods: implications for information systems development
Authors: Richard Baskerville
Venue: ACM Computing Surveys (CSUR) (1993)

The security of information systems is a serious issue because computer abuse is increasing. It is important, therefore, that systems analysts and designers develop expertise in methods for specifying information systems security. The characteristics found in three generations of general information system design methods provide a framework for comparing and understanding current security design methods. These methods include approaches that use checklists of controls, divide functional requirements into engineering partitions, and create abstract models of both the problem and the solution. Comparisons and contrasts reveal that advances in security methods lag behind advances in general systems development methods. This analysis also reveals that more general methods fail to consider security specifications rigorously.
Adaptive checkpointing in Time Warp
Authors: Robert Rönngren, Rassul Ayani
Venue: Proceedings of the eighth workshop on Parallel and distributed simulation (1994)

In Time Warp optimistic discrete event simulation, there exists a need to occasionally save the states of the logical processes. The state saving often constitutes a substantial overhead. However it is not necessary to save each state of a logical process since states can be restored from earlier states by re-executing intermediate events. In this paper, we analyse the effects of doing the state saving less frequently and present a method that allows each logical process to adapt its state saving interval to its rollback behaviour. Experimental results indicate that the proposed method improves performance of the Time Warp system.
The human guidance of automated design
Authors: Lynne Colgan, Robert Spence, Paul Rankin
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

This 5-minute video describes the potential of automated design (optimisation) and identifies associated difficulties which can be overcome by an interface allowing the designer to guide the automated design process. Within the context of electronic circuit design the video then shows a system, called CoCo, for the c&barbelow;ontrol and o&barbelow;bservation of c&barbelow;ircuit o&barbelow;ptimisation. Illustrations focus on graphical interfaces used for (a) describing the circuit, (b) describing the required performance and (c) the human guidance of the automated design of that circuit. Jargon has been suppressed so that workers in related fields can see the implications of the idea.
Improving abstract interpretations by combining domains
Authors: M. Codish, A. Mulkers, M. Bruynooghe, M. García de la Banda, M. Hermenegildo
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

In this paper we consider static analyses based on abstract interpretation of logic programs over combined domains. It is known that analyses over combined domains potentially provide more information than obtainable by performing the independent abstract interpretations. However, the construction of a combined analysis often requires redefining the basic operations for the combined domain. We demonstrate for logic programs that in practice it is possible to obtain precision in a combined analysis without redefining the basic operations. We also propose a way of performing the combination which can be more precise than the straightforward application of the classical &ldquo;reduced product&rdquo; approach, while keeping the original components of the basic operations. The advantage of the approach is that proofs of correctness for the new domains are not required and implementations can be reused. We illustrate our results by showing that a combined sharing analysis&mdash;constructed from &ldquo;old&rdquo; proposals&mdash;compares well with other &ldquo;new&rdquo; proposals suggested in recent literature both from the point of view of efficiency and accuracy.
The effect of synchronization requirements on the performance of distributed simulations
Authors: Murali S. Shanker, B. Eddy Patuwo
Venue: ACM SIGSIM Simulation Digest (1993)

Recent experiments have shown that conservative methods can achieve good performance by exploiting the characteristics of the system being simulated. In this paper we focus on the interrelationship between run time and synchronization requirements of a distributed simulation. A metric that considers the effect of lookahead and the physical rate of transmission of messages, and an arrival approximation that models the effect of synchronization requirements on the run time are developed. It is shown that even when good lookahead is exploited in the system, poor run-time performance is achieved if an inefficient mapping of LPs to processors is used.
Random oracles are practical: a paradigm for designing efficient protocols
Authors: Mihir Bellare, Phillip Rogaway
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

We argue that the random oracle model&mdash;where all parties have access to a public random oracle&mdash;provides a bridge between cryptographic theory and cryptographic practice. In the paradigm we suggest, a practical protocol P is produced by first devising and proving correct a protocol PR for the random oracle model, and then replacing oracle accesses by the computation of an &ldquo;appropriately chosen&rdquo; function h. This paradigm yields protocols much more efficient than standard ones while retaining many of the advantages of provable security. We illustrate these gains for problems including encryption, signatures, and zero-knowledge proofs.
On lazy natural numbers with applications to computability theory and functional programming
Authors: Martín Hötzel Escardó
Venue: ACM SIGACT News (1993)

Lazy natural numbers arise by lazy evaluation of the successor function. This work investigates fundamental mathematical properties of the domain L of lazy natural numbers, and presents applications to computability theory and functional programming. It is shown that certain functions on sets of natural numbers like cardinality-finding and emptyness-testing which are not continuous (or even monotonic) when sets are given by characteristic functions N perp; rarr; T are both continuous and computable when sets are given by characteristic functions L rarr; T defined in an appropriate way. These functions are definable in lambda; calculus based functional programming languages provided some parallel features are available.
The point-range tree: a data structure for indexing intervals
Authors: Moez Chaabouni, Soon M. Chung
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

In this paper, we propose a data structure, the Point-Range Tree (PR-Tree), specifically designed for indexing intervals. With the PR-Tree, a point data can be queried against a set of intervals to determine which of those intervals overlap the point. The PR-tree allows dynamic insertions and deletions while it maintains itself balanced. A balanced PR-Tree takes &Ogr;(log n) time for search. Insertion, deletion, and storage space have worst case requirements of &Ogr;(n log n + m), &Ogr;(n log2 n + m), and &Ogr;(n log n), respectively, where n is the total number of intervals in the tree, and m the number of nodes visited during insertion and deletion. A modified version of the PR-Tree is also developed to minimize space usage. An additional advantage of the PR-Tree is that it can be easily extended to multi-dimensional domains.
Rotating a graphics image with APL
Authors: Charles W. Hart
Venue: ACM SIGAPL APL Quote Quad (1994)

Graphic transformation is neatly accomplished by using matrices, and hence APL is an excellent language with which to write graphics routines. This paper is a brief tutorial and gives a sample rotation routine. The mathematical foundation and APL2 implementation are given.
Top-Down vs. Bottom-Up Process Improvement
Authors: Martyn Thomas, Frank McGarry
Venue: IEEE Software (1994)

There are two approaches to process improvement. The top-down approach compares an organization's process with some generally accepted standard process. Process improvement is then the elimination of differences between an existing process and a standard one. The assumption is that, once the process is changed the generated products will be improved-or at least the risk of generating new software will he reduced. The bottom-up approach assumes that process change must be driven by an organization's goals, characteristics, product attributes, and experiences. Change is defined by a local domain instead of a universal set of accepted practices. For example, an organization whose primary goal is improving time to market may take a significantly different approach to process change than one whose primary goal is to produce defect-free software.
The design of an object-oriented operating system (abstract): a case study of choices
Authors: Roy H. Campbell, Peter W. Madany
Venue: Addendum to the proceedings on Object-oriented programming systems, languages, and applications (Addendum) (1992)

The Design of an Object-Oriented Operating System: A Case Study of Choices Roy H. Campbell Nayeem Islam, University of Illinois Peter W. Madany, SUN Microsystems This tutorial describes the object-oriented design of a complete operating system, written to be object-oriented, with a user and application interface that is object-oriented. The main objective is to illustrate object-oriented design trade-offs by studying a large object-oriented system, the Choices operating system. Choices is an object-oriented multiprocessor operating system that runs native on SPARC stations, Encore Multimaxes, and IBM PCs. The system is built from a number of frameworks that implement a general file system, persistent store for persistent objects, process switching, parallel processing, distributed processing, interrupt handling, virtual memory, networking, and interprocess communication. If you bring an IBM/PC 386-based portable computer running MS-DOS to the course then you may experiment by writing application programs for PC-Choices. All participants will receive a copy of PC-Choices on a floppy. Participants should have experience with building object-oriented systems and have a basic understanding of operating systems design. Reading knowledge of C++ is helpful, but not necessary.
Experimental results from an automatic test case generator
Authors: Richard A. DeMillo, A. Jefferson Offutt
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (1993)

Constraint-based testing is a novel way of generating test data to detect specific types of common programming faults. The conditions under which faults will be detected are encoded as mathematical systems of constraints in terms of program symbols. A set of tools, collectively called Godzilla, has been implemented that automatically generates constraint systems and solves them to create test cases for use by the Mothra testing system. Experimental results from using Godzilla show that the technique can produce test data that is very close in terms of mutation adequacy to test data that is produced manually, and at substantially reduced cost. Additionally, these experiments have suggested a new procedure for unit testing, where test cases are viewed as throw-away items rather than scarce resources.
The impact of machine learning on expert systems
Authors: David Fogel, John C. Hanson, Russell Kick, Heidar A. Malki, Charles Sigwart, Michael Stinson, Efraim Turban
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

Expert systems are a well-known and well-received technology. It was thought that the performance of a domain expert could not be duplicated by a machine. Expert systems technologies have shown this to be a false belief, and indeed have demonstrated how experts themselves can come to depend on expert systems. Expert systems enjoy widespread use in industrial domains and further uses are planned. The growth in acceptance has been explosive since about 1986. Continued rampant growth appears to depend on cracking the so-called knowledge acquisition bottleneck. The knowledge acquisition bottleneck limits the scalability of expert systems. While it is relatively straightforward to populate a small-scale knowledge base, it becomes more difficult to maintain consistency and validity as the knowledge base grows. Thus, it is important to automate the knowledge acquisition process. A by-product of this process is that any failure of the expert system will be &ldquo;soft.&rdquo; The question is, &ldquo;What impact can machine learning technologies have on knowledge acquisition in the large?&rdquo; The true test will be on prospective industrial applications in areas such as biology, education, geology, medicine, and scientific discovery. Machine learning technologies include expert systems, genetic algorithms, neural networks, random seeded crystal learning, or any effective combinations. Relevant subtopics include: Second generation expert systems &mdash; progress and prognosis Repertory Grids The importance of symbolic and qualitative reasoning The acquisition of fuzzy rules The best learning paradigm or combination of paradigms Impact of machine learning on explanation systems The role of toy domains such as chess Automatic programming revisited Applications to computer vision, decision support systems, diagnosis, helpdesks, optimization, planning, scheduling, et al. Implementation issues using SIMD and MIMD platforms Sources for joint sponsorship Forming industrial partnerships Forming alliances abroad