ppxscal/embedding_network huggingface dataset:
Linear logic and permutation stacks&mdash;the Forth shall be first
Authors: Henry G. Baker
Venue: ACM SIGARCH Computer Architecture News (1994)

Girard's linear logic can be used to model programming languages in which each bound variable name has exactly one "occurrence"---i.e., no variable can have implicit "fan-out"; multiple uses require explicit duplication. Among other nice properties, "linear" languages need no garbage collector, yet have no dangling reference problems. We show a natural equivalence between a "linear" programming language and a stack machine in which the top items can undergo arbitrary permutations. Such permutation stack machines can be considered combinator abstractions of Moore's Forth programming language.
Characterizations of Scaling Functions: Continuous Solutions
Authors: David Colella, Christopher Heil
Venue: SIAM Journal on Matrix Analysis and Applications (1994)

A dilation equation is a functional equation of the form $f(t) = \sum_{k=0}^{N}c_{k}f(2t-k)$, and any nonzero solution of such an equation is called a scaling function. Dilation equations play an important role in several fields, including interpolating subdivision schemes and wavelet theory. This paper obtains sharp bounds for the Holder exponent of continuity of any continuous, compactly supported scaling function in terms of the joint spectral radius of two matrices determined by the coefficients $\{c_{0},\ldots,c_{N}\}$. The arguments lead directly to a characterization of all dilation equations that have continuous, compactly supported solutions.
Monitors and concurrent Pascal: a personal history
Authors: Per Brinch Hansen
Venue: ACM SIGPLAN Notices (1993)

This is a personal history of the early development of the monitor concept and its implementation in the programming language Concurrent Pascal. The paper explains how monitors evolved from the ideas of Dahl, Dijkstra, Hoare, and the author (1971-73). At Caltech the author and his students developed and implemented Concurrent Pascal and used it to write several model operating systems (1974-75). A portable implementation of Concurrent Pascal was widely distributed and used for system design (1976-90). The monitor paradigm was also disseminated in survey papers and text books. The author ends the story by expressing his own mixed feelings about monitors and Concurrent Pascal.
Wide-address spaces: exploring the design space
Authors: Alberto Bartoli, Sape J. Mullender, Martijn van der Valk
Venue: ACM SIGOPS Operating Systems Review (1993)

In a recent issue of Operating System Review, Hayter and McAuley [1991] argue that future high-performance systems trade a traditional, bus-based organization for one where all components are linked together by network switches (the Desk-Area Network). In this issue of Operating System Review, Leslie, McAuley and Mullender conclude that DAN-based architectures allow the exploitation of shared memory on a wider scale than just a single (multi)processor. In this paper, we will explore how emerging 64-bit processors can be used to implement shared address spaces spanning multiple machines.
A Systematic Approach for Mapping Application Tasks in Hypercubes
Authors: A. Kavianpour, N. Bagherzadeh
Venue: IEEE Transactions on Computers (1993)

A systematic approach for mapping application tasks to hypercubes is proposed. This method is based on a partitioning algorithm in which the final mapping is rendered as a task-node tuple assignment for an n-cube system. For this method, a single-tasking environment in which each task is assigned to a unique processor is assumed. Dilation-bound and expansion-ratio parameters are used to evaluate the efficacy of this mapping algorithm. An algorithm that minimizes the expansion-ratio parameter is introduced. In addition, an algorithm that reduces the dilaton bound is proposed. Because of the structured formation of the algorithms, they can be applied to any given task structure. As an illustration of the effectiveness of this method, the proposed algorithms are applied to mapping complete binary and d-ary tree task structures to hypercubes.
Implementing analysable hard real-time sporadic tasks in Ada 9X
Authors: A. Burns, A. J. Wellings
Venue: ACM SIGAda Ada Letters (1994)

In this paper we illustrate how systems containing hard real-time sporadic tasks can be analysed for their worst case behaviour. In order to undertake this schedulability analysis, it is necessary to define the minimum inter-arrival time and/or maximum arrival frequency of sporadic tasks. Furthermore, at run-time it is essential to ensure that sporadic tasks are not invoked more often than has been guaranteed by the analysis. We assume that sporadics are invoked by interrupts and that interrupts can be masked under software control.Sporadic tasks are often analysed using the notion of bandwidth preserving sporadic servers within the Rate Monotonic Scheduling Analysis scheme. At run-time this requires the underlying kernel to support complex execution time monitoring mechanisms. Unfortunately such mechanisms are not generally supported by Ada 9X. This paper shows that by using Deadline Monotonic Scheduling Analysis there is no need to resort to bandwidth preserving sporadic servers, and the facilities available in Ada 9X can be used.
A comparison of two model-based performance-prediction techniques for message-passing parallel programs
Authors: Pankaj Mehra, Catherine H. Schulbach, Jerry C. Yan
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

This paper describes our experience in modeling two significant parallel applications: ARC2D, a 2-dimensional Euler solver; and, Xtrid, a tridiagonal linear solver. Both of these models were expressed in BDL (Behavior Description language) and simulated on an iPSC/860 Hypercube modeled using Axe (Abstract eXecution Environment). BDL models consist of abstract communicating objects: blocks of sequential code are modeled by single RUN statements; all communication operations in the original code are mirrored by corresponding BDL operations in the model. Our ARC2D model was built by first profiling the program to locate the significant loops and then timing the basic blocks within those loops. Simulated completion times were (except in one case) within 8% of measured execution times. Lengthy simulations were necessary for predicting the performance of large-scale runs. For Xtrid, only the loops surrounding communications were modeled; other loops were absorbed into large sequential blocks whose complexity was estimated using statistical regression. This approach yielded a much smaller model whose computation and communication complexities were clearly manifest. Analysis of complexity allowed rapid prediction of large-scale performance without lengthy simulations! Analytically predicted speed-ups were within 7% of those predicted by simulation. Simulated completion times were within 5% of measured execution times. The second approach provides a more effective methodology for simulation-based performance-tuning.
Ada design of a neural network
Authors: Jeffrey R. Carter, Bo I. Sanden
Venue: ACM SIGAda Ada Letters (1994)

A neural network is a computer program structured as a simplified model of a brain. It contains nodes (analogous to neurons) and connections between nodes (analogous to synapses). Neural networks can solve difficult pattern-matching problems. A node sums the inputs it receives from other nodes and passes the result through a transfer function to produce its output. A modifiable weight is associated with each connection. A network is trained on a given training set of inputs. During training, the weights are successively adjusted to produce the desired output.Classical design and implementation of neural networks are based on arrays that hold the node values and connection weights. The control structure consists of nested loops through these arrays. This paper suggests instead an object-based design where the nodes are modeled as objects to be operated on. This design models the conceptual network more closely and makes the software more understandable and maintainable. A generic Ada package representing a neural network is presented in some detail.
On the evaluation of Boolean operators in the extended Boolean retrieval framework
Authors: Joon Ho Lee, Won Yong Kin, Myoung Ho Kim, Yoon Joon Lee
Venue: Proceedings of the 16th annual international ACM SIGIR conference on Research and development in information retrieval (1993)

The retrieval models based on the extended boolean retrieval framework, e.g., the fuzzy set model and the extended boolean model have been proposed in the past to provide the conventional boolean retrieval system with the document ranking facility. However, due to undesirable properties of evaluation formulas for the AND and OR operations, the former generates incorrect ranked output in certain cases and the latter suffers from the complexity of computation. There have been a variety of fuzzy operators to replace the evaluation formulas. In this paper we first investigate the behavioral aspects of the fuzzy operators and address important issues to affect retrieval effectiveness. We then define an operator class called positively compensatory operators giving high retrieval effectiveness, and present a pair of positively compensatory operators providing high retrieval efficiency as well as high retrieval effectiveness. All the claims are justified through experiments.
Array-data flow analysis and its use in array privatization
Authors: Dror E. Maydan, Saman P. Amarasinghe, Monica S. Lam
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

Data-flow analysis of scalar variables and data dependence analysis on array elements are two important program analyses used in optimizing and parallelizing compilers. Traditional data-flow analysis models accesses of array elements simply as accesses to the entire array, and is inadequate for parallelizing loops in array-based programs. On the other hand, data dependence analysis differentiates between different array elements but is flow-insensitive. This paper studies the combination of these two analyses&mdash;data-flow analyses&mdash;data-flow analysis of accesses to individual array elements. The problem of finding precise array dataflow information in the domain of loop nests where the loop bounds and array indices are affine functions of loop indices was first formulated by Feautrier. Feautrier's algorithm, based on parametric integer programming techniques, is general but inefficient. This paper presents an efficient algorithm that can find the same precise information for many of the programs found in practice. In this paper, we argue that data-flow analysis of individual array elements is necessary for effective automatic parallelization. In particular, we demonstrate the use of array data-flow analysis in an important optimization known as array privatization. By demonstrating that array data-flow analysis can be computed efficiently and by showing the importance of the optimizations enabled by the analysis, this paper suggests that array data-flow analysis may become just as important in future optimizing and parallelizing compilers as data-flow and data dependence analysis are in today's compilers.
Automatic compiler recognition of monitor tasks
Authors: Jonathan L. Schilling, Johan Olmütz Nielsen
Venue: ACM SIGAda Ada Letters (1994)

Monitor tasks, also known as passive tasks, are a kind of Ada task that is subject to well-known and very powerful optimization. In most compilation systems that perform this optimization, monitor tasks are identified to the complier by the user, via an implementation-defined pragma. This paper describes an alternate approach, whereby the compiler automatically recognizes and optimizes monitor tasks, without need of a pragma, compiler option, or any other user action. The advantages and disadvantages of this approach are discussed, both in terms of the functional impact to the user and the execution-time efficiency of the optimization.
Integration of interpersonal space and shared workspace: ClearBoard design and experiments
Authors: Hiroshi Ishii, Minoru Kobayashi, Jonathan Grudin
Venue: ACM Transactions on Information Systems (TOIS) (1993)

We describe the evolution of the novel shared drawing medium ClearBoard which was designed to seamlessly integrate an interpersonal space and a shared workspace. ClearBoard permits coworkers in two locations to draw with color markers or with electronic pens and software tools while maintaining direct eye contact and the ability to employ natural gestures. The ClearBoard design is based on the key metaphor of &ldquo;talking through and drawing on a transparent glass window.&rdquo; We describe the evolution from ClearBoard-1 (which enables shared video drawing) to ClearBoard-2 (which incorporates TeamPaint, a multiuser paint editor). Initial observations and findings gained through the experimental use of the prototype, including the feature of &ldquo;gaze awareness,&rdquo; are discussed. Further experiments are conducted with ClearBoard-0 (a simple mockup), ClearBoard-1, and an actual desktop as a control. In the settings we examined, the ClearBoard environment led to more eye contact and potential awareness of collaborator's gaze direction over the traditional desktop environment.
Database conversion planning
Authors: Motamarri Saradhi
Venue: ACM SIGSOFT Software Engineering Notes (1993)

In conventional approaches to Systems Development the crucial task of the exercise, deployment figures almost, at the end! The performance of the developed software can only be realized if and only if, there is a database to interact with. Surprisingly, this slips the attention of system developers! The challenge of converting the existing manual system, of all, the database maintained in paper volumes to that of computerized version, is not well accounted for. However, mundane this task, Database Conversion Planning (DBCP), has a definite and dominant role to play in systems development. While handling several complex turnkey computerization projects, we are compelled to realize the criticality of DBCP. A careful consideration of these issues in the early stages of systems development has shown a multitude of benefits. As a result, we were able to deploy projects amidst several constraining and conflicting factors. The projects have won the appreciation of customers, of all, end-users. We would like to share the vision that had lead to the creation of these systems, where software and quality have only synonymous meaning! We finally wish that these thoughts will influence the practice of systems development or in general, software engineering.
Reverse engineering questionnaire
Authors: Kostas A. Kontogiannis, Scott R. Tilley
Venue: ACM SIGSOFT Software Engineering Notes (1994)

This is a questionnaire on program understanding and reverse engineering. It may be filled out manually or on-line. The results of the questionnaire will be used to guide the research of the two authors, both of whom are Ph.D. students working in this area. Copies of the resulting report will be mailed to all who participate, and a summary of the results will be published in an appropriate forum.
Content-based retrieval in multimedia databases
Authors: C. H. C. Leung, J. Hibler, N. Mwara
Venue: ACM SIGGRAPH Computer Graphics (1994)

The flexible retrieval of pictorial data on the basis of content hinges on the ability to model multimedia data effectively. In using the entity-attribute-relationship model, the main semantic concepts of entity, attribute and relationship can be represented in a simple manner which correspond very closely to the noun, adjective and verb which are the essential components of a simple description of a picture. Such a system has an advantage over traditional ways of representing the data in an automated system in that it allows the concept of relationships between two (or more) objects within a picture to be represented in the database.Our basic starting point is man-machine cooperation in which the pattern processing capability of the human eye is fully exploited. As a result, it should provide a much better degree of flexibility in the identification of complex high-level patterns. We also introduce a picture description language which allows the contents of pictures to be systematically represented, these resultant representations can then be stored for subsequent processing. Picture retrieval is accomplished by specifying picture queries using a picture query language. Evaluation experiments carried out on a prototype system show that this approach is able to yield precision and recall performances of over 62% and 88% respectively.
Using shared virtual memory for parallel join processing
Authors: Ambuj Shatdal, Jeffrey F. Naughton
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

In this paper, we show that shared virtual memory, in a shared-nothing multiprocessor, facilitates the design and implementation of parallel join processing algorithms that perform significantly better in the presence of skew than previously proposed parallel join processing algorithms. We propose two variants of an algorithm for parallel join processing using shared virtual memory, and perform a detailed simulation to investigate their performance. The algorithm is unique in that it employs both the shared virtual memory paradigm and the message-passing paradigm used by current shared-nothing parallel database systems. The implementation of the algorithm requires few modifications to existing shared-nothing parallel database systems.
Compilation techniques for block-cyclic distributions
Authors: Seema Hiranandani, Ken Kennedy, John Mellor-Crummey, Ajay Sethi
Venue: Proceedings of the 8th international conference on Supercomputing (1994)

Compilers for data-parallel languages such as Fortran D and High-Performance Fortran use data alignment and distribution specifications as the basis for translating programs for execution on MIMD distributed-memory machines. This paper describes techniques for generating efficient code for programs that use block-cyclic distributions. These techniques can be applied to programs with symbolic loop bounds, symbolic array dimensions, and loops with non-unit strides. We present algorithms for computing the data elements that need to be communicated among processors both for loops with unit and non-unit strides, a linear-time algorithm for computing the memory access sequence for loops with non-unit strides, and experimental results for a hand-compiled test case using block-cyclic distributions
Universal finiteness and satisfiability (extended abstract)
Authors: Inderpal Singh Mumick, Oded Shmueli
Venue: Proceedings of the thirteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1994)

The problem of determining whether, for every extensional database, a given predicate in a given program has a finite number of derivations is called the universal finiteness problem. The problem of determining whether a given predicate in a given program has a non-empty extension for some extensional database is called the satisfiability problem. We show that the universal finiteness problem can be reduced to the satisfiability problem. Thus all decidability results for satisfiability can be applied to universal finiteness&mdash;for example, we can infer that the universal finiteness problem is decidable for Datalog extended with negation on base predicates. The satisfiability problem can be easily reduced to the universal finiteness problem, so that all undecidability results for satisfiability can be applied to universal finiteness. For example we can infer that the universal finiteness problem is undecidable for Datalog extended with stratified negation.Many recursive programs have infinite number of derivations only when ed b relations have data cycles. It is thus of particular interest to study universal finiteness in the presence of acyclicity constraints on the ed b relations. We define acyclicity constraints in terms of non-satisfiability of a specific recursive program. We show that both the problems of universal finiteness and satisfiability of Datalog in the presence of acyclicity constraints (on one or more ed b relations) remain decidable for a language L whenever the problems are decidable for language L in absence of such constraints. We also show that the problems are undecidable for arbitrary constraints expressed in terms of non-satisfiability of a recursive program.
Fast Self-Routing Permutation Switching on an Asymptotically Minimum Cost Network
Authors: Ching Yuh Jan, A. Yavuz Oruç
Venue: IEEE Transactions on Computers (1993)

A self-routing permutation network with O((n lg n)) switches and O(lg/sup 2/n) routing time, where lg denotes log/sub 2/, is presented. More generally, a permutation network with O(kn/sup 1+1/k/) cost and O(k lg n) routing time for any k, 1>or=k lg n, is described. This improves D. Nassimi and J. Sahni's (1982) routing algorithm that gives O(k lg/sup 3/ n) routing time for the same cost expression. The only networks capable of permutation switching with O(n lg n) cost and O(lg n) routing time are the AKS sorting network and E. Upfal's (1989) packet routing network, but the constants hidden in the complexities of these networks are so large that they remain impractical until n gets very large.
Schema updates for object-oriented database systems (abstract)
Authors: Roberto Zicari
Venue: ACM SIGPLAN OOPS Messenger (1993)

Schema Updates for Object-Oriented Database Systems Roberto Zicari , Johann Wolfgang Goethe University, Germany OODBMS are often used for complex data whose structure is likely to change over time, yet the problem of schema updates has not been completely solved by any commercial or research OODBMS. This tutorial describes the schema modification problem and why it is important, what is really offered by products, what a good solution would be like, and whether we are likely to see it soon. The tutorial reviews several commercial OODBMS products that provide facilities for updating the schema, namely: Gemstone (Servio Corporation), ITASCA(Itasca), 02(02Technology), ObjectStore (ObjectDesign), Ontos (Ontologic) and Statice (Symbolics). It also describes the solutions proposed in some experimental research prototypes and the open problems that remain.
The generating power of the boundary NLC graph grammars
Authors: Koichi Yamazaki
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

It is known that Ga (Ga is the set of all graphs labeled by a single label a) is an NLC language [3, 1980], Ca (Ca is the set of all cycle graphs labeled by a single label a) is not an NLC language [1, 1984], and Ga is not a BNLC language [8, 1986]. In this paper, we consider the class Lc of all graph languages including Ca. We show that the class Lc and the class of BNLC graph languages are mutually disjoint. We note that Ca and Ga are elements of Lc.
Software reuse based on a large object-oriented library
Authors: Hsian-Chou Liao, Feng-Jian Wang
Venue: ACM SIGSOFT Software Engineering Notes (1993)

Object-oriented software libraries expand in size more rapidly than other type of software library. This paper presents a simple approach for aiding reuse in software development using object-oriented library. Our approach improves the effectiveness of code searching by reorganizing the library with facet classification scheme and thesaurus. Information in specification models, such as data flow diagrams (DFDs), is extracted through object abstraction and then used as a query input. We are currently implementing a Computer-Aided Reuse Tool (CART) based on the approach.