ppxscal/embedding_network huggingface dataset:
Defining, Analyzing, and Transforming Program Constructs
Authors: Jingke Li, Michael Wolfe
Venue: IEEE Parallel Distributed Technology: Systems Technology (1994)

We have developed a framework for analyzing the behavior and relations of various sequential and parallel control constructs, which we can nest in a very general way. A simple yet powerful scheme defines the order of data accesses in a program, and provides a well-founded semantic structure for nested constructs. When defining parallel languages or extensions to current languages, designers can use this framework to define how each new feature interacts with the language's other features. Because our approach is based on well-known dependence analysis techniques, it is practical for compiler implementation. It determines which behavior the compiler and system must preserve while allowing aggressive automatic optimization. Instead of being confined to a single programming paradigm, programmers can use the most appropriate constructs for the application, and the compiler can transform and optimize the program for different parallel or sequential architectures.
Test case generation by means of learning techniques
Authors: F. Bergadano
Venue: Proceedings of the 1st ACM SIGSOFT symposium on Foundations of software engineering (1993)

Given a program P and a set of alternative programs P, we generate a sequence of test cases that are adequate, in the sense that they distinguish the given program from all alternatives. The method is related to fault-based approaches to program testing, but programs in P need not be simple mutations of P. The technique for generating an adequate test set is based on the inductive learning of programs from finite sets of input-output examples: given a partial test set, we generate inductively a program P'E P which is consistent with P on those input values; then we look for an input value that distinguishes P from P', and repeat the process until no program except P can be induced from the generated examples. We show that the so obtained test set is adequate w.r.t. the alternatives belonging to P. The method is made possible by a practical program induction procedure, which has evolved from recent research in Machine Learning and Inductive Logic Programming.
Real-time transaction scheduling: a cost conscious approach
Authors: D. Hong, T. Johnson, S. Chakravarthy
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Real-time databases are an important component of embedded real-time systems. In a real-time database context, transactions must not only maintain the consistency constraints of the database but must also satisfy the timing constraints specified for each transaction. Although several approaches have been proposed to integrate real-time scheduling and database concurrency control methods, none of them take into account the dynamic cost of scheduling a transaction. In this paper, we propose a new cost conscious real-time transaction scheduling algorithm which considers dynamic costs associated with a transaction. Our dynamic priority assignment algorithm adapts to changes in the system load without causing excessive numbers of transaction restarts. Our simulations show its superiority over EDF-HP algorithm.
The conjugate gradient method in the presence of clustered eigenvalues
Authors: José D. Flores
Venue: ACM SIGSMALL/PC Notes (1993)

We present the conjugate gradient method, CG method, to solve large dense linear systems whose associated matrix has clustered eigenvalues, and we give the implementation of the algorithm using MATLAB, an interactive programming language for scientific computing.
Communication optimization and code generation for distributed memory machines
Authors: Saman P. Amarasinghe, Monica S. Lam
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

This paper presents several algorithms to solve code generation and optimization problems specific to machines with distributed address spaces. Given a description of how the computation is to be partitioned across the processors in a machine, our algorithms produce an SPMD (single program multiple data) program to be run on each processor. Our compiler generated the necessary receive and send instructions, optimizes the communication by eliminating redundant communication and aggregating small messages into large messages, allocates space locally on each processor, and translates global data addresses to local addresses. Our techniques are based on an exact data-flow analysis on individual array element accesses. Unlike data dependence analysis, this analysis determines if two dynamic instances refer to the same value, and not just to the same location. Using this information, our compiler can handle more flexible data decompositions and find more opportunities for communication optimization than systems based on data dependence analysis. Our technique is based on a uniform framework, where data decompositions, computation decompositions and the data flow information are all represented as systems of linear inequalities. We show that the problems of communication code generation, local memory management, message aggregation and redundant data communication elimination can all be solved by projecting polyhedra represented by sets of inequalities onto lower dimensional spaces.
The essence of compiling with continuations
Authors: Cormac Flanagan, Amr Sabry, Bruce F. Duba, Matthias Felleisen
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

In order to simplify the compilation process, many compilers for higher-order languages use the continuation-passing style (CPS) transformation in a first phase to generate an intermediate representation of the source program. The salient aspect of this intermediate form is that all procedures take an argument that represents the rest of the computation (the &ldquo;continuation&rdquo;). Since the nai&uml;ve CPS transformation considerably increases the size of programs, CPS compilers perform reductions to produce a more compact intermediate representation. Although often implemented as a part of the CPS transformation, this step is conceptually a second phase. Finally, code generators for typical CPS compilers treat continuations specially in order to optimize the interpretation of continuation parameters. A thorough analysis of the abstract machine for CPS terms show that the actions of the code generator invert the nai&uml;ve CPS translation step. Put differently, the combined effect of the three phases is equivalent to a source-to-source transformation that simulates the compaction phase. Thus, fully developed CPS compilers do not need to employ the CPS transformation but can achieve the same results with a simple source-level transformation.
Helly theorems and generalized linear programming
Authors: Nina Amenta
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

Recent combinatorial algorithms for linear programming also solve certain non-linear problems. We call these Generalized Linear Programming, or GLP, problems. One way in which convexity has been generalized by mathematicians is through a collection of results called the Helly theorems. We show that the every GLP problem implies a Helly theorem, and we give two paradigms for constructing a GLP problem from a Helly theorem. We give many applications, including linear expected time algorithms for finding line transversals and hyperplane fitting in convex metrics. These include GLP problems with the surprising property that the constraints are non-convex or even disconnected. We show that some Helly theorems cannot be turned into GLP problems.
Shortest paths among obstacles in the plane
Authors: Joseph S. B. Mitchell
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

We give a subquadratic (O(n5/3+&egr;) time and space) algorithm for computing Euclidean shortest paths in the plane in the presence of polygonal obstacles; previous time bounds were at least quadratic in n, in the worst-case. The method avoids use of visibility graphs, relying instead on the continuous Dijkstra paradigm. The output is a shortest path map (of size O(n)) with respect to a given source point, which allows shortest path length queries to be answered in time O(log n). The algorithm extends to the case of multiple source points, yielding a geodesic Voronoi diagram within the same time bound.
Nonnegative Hall Polynomials
Authors: Lynne M. Butler, Alfred W. Hales
Venue: Journal of Algebraic Combinatorics: An International Journal (1993)

The number of subgroups of type &mu; and cotype &nu; in a finite abelian p-group of type &lambda; is a polynomial g_{\mu \nu}^\lambda(p) with integral coefficients. We prove g_{\mu \nu}^\lambda(p) has nonnegative coefficients for all partitions &mu; and &nu; if and only if no two parts of &lambda; differ by more than one. Necessity follows from a few simple facts about Hall-Littlewood symmetric functions&semi; sufficiency relies on properties of certain order-preserving surjections &phiv; that associate to each subgroup a vector dominated componentwise by &lambda;. The nonzero components of &phiv;(H) are the parts of &mu;, the type of H&semi; if no two parts of &lambda; differ by more than one, the nonzero components of &lambda; &minus; &phiv;(H) are the parts of &nu;, the cotype of H. In fact, we provide an order-theoretic characterization of those isomorphism types of finite abelian p-groups all of whose Hall polynomials have nonnegative coefficients.
Using ABC to prototype VDM specifications
Authors: Aaron Kans, Clive Hayton
Venue: ACM SIGPLAN Notices (1994)

ABC is a high-level, easy-to-use imperative language, designed originally as a replacement for BASIC. Although intended primarily as a teaching language, it has many powerful attributes that make it suitable as a language for the rapid prototyping of formal specifications. This paper illustrates how ABC was used to prototype specifications written in the formal specification language of VDM.
The stage one Turing test as an artificial intelligence class exercise
Authors: Nancy Lynn Tinkham, Darren F. Provine
Venue: ACM SIGCSE Bulletin (1994)

This paper describes an implementation of the man-woman Turing test as a class exercise in an artificial intelligence course. The exercise helps students to understand more clearly the difficulties and challenges involved in designing an artificially intelligent computer to pass the more famous person-computer Turing test.
Shared variables in distributed simulation
Authors: Horst Mehl, Stefan Hammes
Venue: Proceedings of the seventh workshop on Parallel and distributed simulation (1993)

Although users may want to employ shared variables when they program distributed simulation applications, almost none of the currently existing distributed simulation systems do offer this facility. In this paper, we present new algorithms which provide the illusion of consistent shared variables in distributed simulation systems without physically shared memmory.
Making object-oriented schemas more expressive
Authors: Diego Calvanese, Maurizio Lenzerini
Venue: Proceedings of the thirteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1994)

Current object-oriented data models lack several important features that would allow one to express relevant knowledge about the classes of schema. In particular, there is no data model supporting simultaneously the inverse of the functions represented by attributes, the union, the intersection and the complement of classes, the possibility of using nonbinary relations, and the possibility of expressing cardinality constraints on attributes and relations. In this paper we define a new data model, called CAR, which extends the basic core of current object-oriented data models with all the above mentioned features. A technique is then presented both for checking the consistency of class definitions, and for computing the logical sequences of the knowledge represented in the schema. Finally, the inherent complexity of reasoning in CAR is investigated, and the complexity of our inferencing technique is studied, depending on various assumptions on the schema.
Scheduling algorithms for modern disk drives
Authors: Bruce L. Worthington, Gregory R. Ganger, Yale N. Patt
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

Disk subsystem performance can be dramatically improved by dynamically ordering, or scheduling, pending requests. Via strongly validated simulation, we examine the impact of complex logical-to-physical mappings and large prefetching caches on scheduling effectiveness. Using both synthetic workloads and traces captured from six different user environments, we arrive at three main conclusions: (1) Incorporating complex mapping information into the scheduler provides only a marginal (less than 2%) decrease in response times for seek-reducing algorithms. (2) Algorithms which effectively utilize prefetching disk caches provide significant performance improvements for workloads with read sequentiality. The cyclical scan algorithm (C-LOOK), which always schedules requests in ascending logical order, achieves the highest performance among seek-reducing algorithms for such workloads. (3) Algorithms that reduce overall positioning delays produce the highest performance provided that they recognize and exploit a prefetching cache.
&ldquo;D2R&rdquo;: a dynamic dataflow representation for task scheduling
Authors: Johann Rost
Venue: ACM SIGPLAN Notices (1993)

The task-level dataflow language D2R ("Dynamic Dataflow Representation") is suggested (Version 1.0). D2R uses dynamic branching, loops with data-dependent numbers of iterations and alternatives. The dataflow information can be expressed either as a program text or as graph. Primarily the model has been developed for cooperation with dynamic task scheduling algorithms. Its suitability is demonstrated by examples. The representation supports environments allowing to simultaneously execute multiple user programs ("space sharing") as well as to restrict the assignments of task and data nodes to special processors (e.g. I/O nodes). The system has been implemented using the multi transputer system "DAMP" /Bauch-91/.
Response to &ldquo;Remarks on two new theorems of Date and Fagin&rdquo;
Authors: C. J. Date, Ronald Fagin
Venue: ACM SIGMOD Record (1993)

In [DF92], we present simple conditions, which we now describe, for guaranteeing higher normal forms for relational databases. A key is simple if it consists of a single attribute. We show in [DF92] that if a relation schema is in third normal form (3NF) and every key is simple, then it is in projection-join normal form (sometimes called fifth normal form), the ultimate normal form with respect to projections and joins. We also show in [DF92] that if a relation schema is in Boyce-Codd normal form (BCNF) and some key is simple, then it is in fourth normal form (4NF). These results give the database designer simple sufficient conditions, defined in terms of functional dependencies alone, that guarantee that the schema being designed is automatically in higher normal forms.
Test template framework: a specification-based testing case study
Authors: P. Stocks, D. Carrington
Venue: Proceedings of the 1993 ACM SIGSOFT international symposium on Software testing and analysis (1993)

A framework for specification-based testing is demonstrated on a symbol table case study, specified using the Z notation. Test derivation and structuring is discussed, as well as applications of the framework in deriving test oracles and aiding regressing testing during maintenance. Areas for further research and discussion are comparison of heuristics with regard to generated test suites and usability, formalising testing heuristics, and the discrepancy between functional testing and robustness testing.
Yaged: a teaching resource for image manipulation, Xlib graphics and usability engineering
Authors: Fintan Culwin
Venue: ACM SIGGRAPH Computer Graphics (1994)

Yaged (yet another graphics editor) is a pixmap graphics editor which has been developed as an environment where novice graphics programmers can implement image manipulation algorithms, two dimensional drawing tools and GUIs, within the context of a realistic application. Yaged has been implemented with the X/Motif toolkit, using defined production processes, and is fully documented using a usability based, object oriented notation. The full source code for the application and the design documentation is freely available via anonymous ftp.
The early history of Smalltalk
Authors: Alan C. Kay
Venue: ACM SIGPLAN Notices (1993)

Most ideas come from previous ideas. The sixties, particularly in the ARPA community, gave rise to a host of notions about &ldquo;human-computer symbiosis&rdquo; through interactive time-shared computers, graphics screens and pointing devices. Advanced computer languages were invented to simulate complex systems such as oil refineries and semi-intelligent behavior. The soon to follow paradigm shift of modern personal computing, overlapping window interfaces, and object-oriented design came from seeing the work of the sixties as something more than a &ldquo;better old thing&rdquo;. That is, more than a better way: to do mainframe computing; for end-users to invoke functionality; to make data structures more abstract. Instead the promise of exponential growth in computing/$/volume demanded that the sixties be regarded as &ldquo;almost a new thing&rdquo; and to find out what the actual &ldquo;new things&rdquo; might be. For example, one would compute with a handheld &ldquo;Dynabook&rdquo; in a way that would not be possible on a shared mainframe; millions of potential users meant that the user interface would have to become a learning environment along the lines of Montessori and Bruner; and needs for large scope, reduction in complexity, and end-user literacy would require that data and control structures be done away with in favor of a more biological scheme of protected universal cells interacting only through messages that could mimic any desired behavior. Early Smalltalk was the first complete realization of these new points of view as parented by its many predecessors in hardware, language and user interface design. It became the exemplar of the new computing, in part, because we were actually trying for a qualitative shift in belief structures&mdash;a new Kuhnian paradigm in the same spirit as the invention of the printing press&mdash;and thus took highly extreme positions which almost forced these new styles to be invented.
Measurement-driven restructuring of object oriented applications
Authors: Nadir Yousfi
Venue: Addendum to the proceedings on Object-oriented programming systems, languages, and applications (Addendum) (1992)

In a class hierarchy, a method should have access to only as many attributes as it needs to do its job. In general case, object programmers do not have regard to such an optimizing criterion. Consequent defaults are displayed and measured. In analyzing the way class attributes are used by methods, can we define alternative classes, not containing more attributes than are needed? Is it possible to translate an application into one achieving the same purpose but with attributes more efficiently spread in class hierarchy? We propose a reversible technique for restructuring that may answer these questions. Indirectly, it provides by measurement a way for localizing attributes and restricting their use in an object system. [Lieb 88], [Parn 86].
Towards better inlining decisions using inlining trials
Authors: Jeffrey Dean, Craig Chambers
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

Inlining trials are a general mechanism for making better automatic decisions about whether a routine is profitable to inline. Unlike standard source-level inlining heuristics, an inlining trial captures the effects of optimizations applied to the body of the inlined routine when calculating the costs and benefits of inlining. The results of inlining trials are stored in a persistent database to be reused when making future inlining decisions at similar call sites. Type group analysis can determine the amount of available static information exploited during compilation, and the results of analyzing the compilation of an inlined routine help decide when a future call site would lead to substantially the same generated code as a given inlining trial. We have implemented inlining trials and type group analysis in an optimizing compiler for SELF, and by making wiser inlining decisions we were able to cut compilation time and compiled code space with virtually no loss of execution speed. We believe that inlining trials and type group analysis could be applied effectively to many high-level languages where procedural or functional abstraction is used heavily.
Locality, causality and continuations
Authors: Christian Queinnec
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

Concurrency and distribution are topics exacerbated by the omnipresence of Internet. Although many languages address these topics, few offer a real opportunity to control and coordinate widely spread dynamic computations. This paper presents such a language and its prominent features. Besides explaining the software architecture of the implementation (based on objects and generic functions), it also presents an original coherency protocol for shared mutable variables.We first recall, in Section 1, the main features of our Scheme-based, concurrent, distributed and computation-oriented language already presented in more details and examples in [QD93].Section 2 explains how to systematically implement a concurrent and distributed interpreter for that language, using a set of program transformations combining Abstract Continuation Passing Style (ACPS) and Object-Oriented Lifting. The originality of this implementation is that it chiefly uses objects and generic functions in a style that allows to concentrate the problems related to concurrency and migration of computations into the sole discriminating behavior of generic functions. ACPS is not only used to reify continuations but also to enforce locality of computations in presence of distal objects.In Section 3, we propose a new (to our knowledge) protocol to manage shared mutable variables. This protocol enhances [MSRN92], does not require atomic broadcast, tolerates short communication breakdowns and uses bounded circular clocks. This result comes from the use of a distributed GC (which allows us to maintain an approximation of Global Virtual Time) and from the exploitation of causality as stated by continuations. To give a continuation a value (and a store) clearly expresses that the computations that are present in the continuation causally depend on the invoker of the continuation. Finally the computation-orientation of our language and mainly the ability to control groups of threads, concurrently running on multiple sites for the completion of the evaluation of a single expression, is shortly sketched in Section 4.As usual, related works and conclusions end this paper.
Customizing the SIGCHI curriculum for use in Sweden
Authors: Jonas Löwgren, Lena Holmberg
Venue: ACM SIGCHI Bulletin (1993)

This note describes the work undertaken by the Swedish interdisciplinary interest group for HCI (STIMDI) in order to develop a HCI curriculum for Sweden. Our efforts have been inspired by the ACM SIGCHI curriculum proposal presented recently; we discuss why we felt certain customizations were necessary and present our modified curriculum. We also describe our plans for creating a HCI teaching resource in the form of a commonly accessible database.