ppxscal/embedding_network huggingface dataset:
Graph contraction for physical optimization methods: a quality-cost tradeoff for mapping data on parallel computers
Authors: N. Mansour, R. Ponnusamy, A. Choudhary, G. C. Fox
Venue: Proceedings of the 7th international conference on Supercomputing (1993)

Mapping data to parallel computers aims at minimizing the execution time of the associated application. However, it can take an unacceptable amount of time in comparison with the execution time of the application if the size of the problem is large. In this paper, first we motivate the case for graph contraction as a means for reducing the problem size. We restrict our discussion to applications where the problem domain can be described using a graph (e.g., computational fluid dynamics applications). Then we present a mapping-oriented Parallel Graph Contraction (PGC) heuristic algorithm that yields a smaller representation of the problem to which mapping is then applied. The mapping solution for the original problem is obtained by a straight-forward interpolation. We then present experimental results on using contracted graphs as inputs to two physical optimization methods; namely, Genetic Algorithm and Simulated Annealing. The experimental results show that the PGC algorithm still leads to a reasonably good quality mapping solutions to the original problem, while producing a substantial reduction in mapping time. Finally, we discuss the cost-quality tradeoffs in performing graph contraction.
Synthesis of UNIX Programs Using Derivational Analogy
Authors: Sanjay Bhansali, Mehdi T. Harandi
Venue: Machine Learning (1993)

The feasibility of derivational analogy as a mechanism for improving problem-solving behavior has been shown for a variety of problem domains by several researchers. However, most of the implemented systems have been empirically evaluated in the restricted context of an already supplied base analog or on a few isolated examples. In this paper we describe a derivational analogy based system, APU, that synthesizes UNIX shell scripts from a high-level problem specification. APU uses top-down decomposition of problems, employing a hierarchical planner and a layered knowledge base of rules, and is able to speed up the derivation of programs by using derivational analogy. We assume that the problem specification is encoded in the vocabulary used by the rules. We describe APU's retrieval heuristics that exploit this assumption to automatically retrieve a good analog for a target problem from a case library, as well as its replay algorithm that enables it to effectively reuse the solution of an analogous problem to derive a solution for a new problem. We present experimental results to assess APU's performance, taking into account the cost of retrieving analogs from a sizable case library. We discuss the significance of the results and some of the issues in using derivational analogy to synthesize programs.
Unification using a distributed representation
Authors: A. Browne, J. Pilkington
Venue: ACM SIGART Bulletin (1994)

In the neural network and artificial intelligence research communities at the moment there is an ongoing debate about the representational adequacy of neural networks versus that of classical symbolic systems. Supporters of the classical symbolic AI paradigm argue that systems such as neural networks using a distributed representation do not have the compositionality required to perform structure-sensitive logical tasks. Supporters of the neural network paradigm point to the difficulty symbolic systems have in generalising to novel inputs. We have investigated performing variable binding with a distributed representation by using a neural network to perform unification. The successful performance of this task adds further evidence to the assertion that neural networks using distributed representations can be used to perform complex structure-sensitive tasks.
Program profiling problems, and a solution via machine language rewriting
Authors: John F. Reiser, Joseph P. Skudlarek
Venue: ACM SIGPLAN Notices (1994)

The executable binary image of a program can be mechanically rewritten to produce a second program that collects execution statistics as a side effect, while executing the same routines and producing the same primary outputs as the original program. We describe a general technique and present our experiences with several alternate profiling mechanisms. The challenges of presenting the profile information in easily-used. understandable ways are also discussed.
Cache interference phenomena
Authors: O. Temam, C. Fricker, W. Jalby
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

The impact of cache interferences on program performance (particularly numerical codes, which heavily use the memory hierarchy) remains unknown. The general knowledge is that cache interferences are highly irregular, in terms of occurrence and intensity. In this paper, the different types of cache interferences that can occur in numerical loop nests are identified. An analytical method is developed for detecting the occurrence of interferences and, more important, for computing the number of cache misses due to interferences. Simulations and experiments on real machines show that the model is generally accurate and that most interference phenomena are captured. Experiments also show that cache interferences can be intense and frequent. Certain parameters such as array base addresses or dimensions can have a strong impact on the occurrence of interferences. Modifying these parameters only can induce global execution time variations of 30% and more. Applications of these modeling techniques are numerous and range from performance evaluation and prediction to enhancement of data locality optimizations techniques.
Completeness of Normal Rational Curves
Authors: L. Storme
Venue: Journal of Algebraic Combinatorics: An International Journal (1992)

The completeness of normal rational curves, considered as (q + 1)-arcs in PG(n, q), is investigated. Previous results of Storme and Thas are improved by using a result by Kov&aacute;cs. This solves the problem completely for large prime numbers q and odd nonsquare prime powers q &equals; p2h+1 with p prime, p\geq p_0(h), \ h\geq 1, where p0(h) is an odd prime number which depends on h.
Computer as Thinker/Doer: Problem-Solving Environments for Computational Science
Authors: Efstratios Gallopoulos, Elias Houstis, John R. Rice
Venue: IEEE Computational Science Engineering (1994)

During the early 1960s, scientists began to envision problem-solving computing environments not only powerful enough to solve complex problems but also able to interact with users on human terms. While many tried to create PSEs over the next few years, by the early 1970s they had abandoned almost all of these attempts. Technology could not yet support PSEs in computational science. But the dream of the 1960s can be the reality of the 1990s: high-performance computers combined with better understanding of computing and computational science have put PSEs well within our reach. The term 'problem-solving environment' means different things to different people. A PSE is a computer system that provides all the computational facilities necessary to solve a target class of problems. These features include advanced solution methods, automatic or semi-automatic selection of solution methods, and ways to easily incorporate novel solution methods. Simple PSEs appeared early in computing without being recognized as such. Some of the capabilities of future problem-solving environments seem like science fiction, but whatever form they eventually take, their scientific and economic impact will be enormous.
A user-centred evaluation of ranking algorithms for interactive query expansion
Authors: Efthimis N. Efthimiadis
Venue: Proceedings of the 16th annual international ACM SIGIR conference on Research and development in information retrieval (1993)

The evaluation of 6 ranking algorithms for the ranking of terms for query expansion is discussed within the context of an investigation of interactive query expansion and relevance feedback in a real operational environment. The yardstick for the evaluation was provided by the user relevance judgements on the lists of the candidate terms for query expansion. The evaluation focuses on the similarities in the performance of the different algorithms and how the algorithms with similar performance treat terms.
The LOGRES prototype
Authors: F. Cacace, S. Ceri, S. Crespi-Reghizzi, P. Fraternali, S. Paraboschi, L. Tanca
Venue: ACM SIGMOD Record (1993)

Logres is a new-generation database system integrating features from deductive and object-oriented databases [1, 2, 3, 4, 5]. The data model of Logres supports structural and semantic complexity through a rich collection of concepts from object-oriented models. The rule language allows for the manipulation of complex objects, the generation of new objects, and the definition of passive and active constraints. The application of set of rules to database states is controlled by means of qualifiers, which dictate the side effects of rules; qualifiers are the unique procedural feature of Logres, otherwise a fully declarative language.
MoodView: an advanced graphical user interface for OODBMSs
Authors: İsmailcem Budak Arpinar, Asuman Doğaç, Cem Evrendilek
Venue: ACM SIGMOD Record (1993)

OODBMSs need more than declarative query languages and programming languages as their interfaces since they are designed and implemented for complex applications requiring more advanced and easy to use visual interfaces. We have developed a complete programming environment for this purpose, called MoodView. MoodView translates all the user actions performed through its graphical interface to SQL statements and therefore it can be ported onto any object-oriented database systems using SQL. MoodView provides the database programmer with tools and functionalities for every phase of object oriented database application development. Current version of MoodView allows a database user to design, browse, and modify database schema interactively and to display class inheritance hierarchy as a directed acyclic graph. MoodView can automatically generate graphical displays for complex and multimedia database objects which can be updated through the object browser. Furthermore, a database administration tool, a full screen text-editor, a SQL based query manager, and a graphical indexing tool for the spatial data, i.e., R Trees are also implemented.
A Multistate, Multicontrol Problem with Unbounded Controls
Authors: J. R. Dorroh, Guillermo Ferreyra
Venue: SIAM Journal on Control and Optimization (1994)

This paper gives the optimal synthesis for a two-dimensional singular control problem of the Vidale--Wolfe type. The controls take values in an unbounded set. Moreover, the optimal feedback control turns out to be impulsive on certain regions, and the order in which these impulses occur is important. A parameterization of time is introduced into the problem. This helps to elucidate the optimal synthesis, to prove its optimality by the verification method, and to design suboptimal physical approximations to the optimal impulsive control.
Efficient implementation of event sets in Time Warp
Authors: Robert Rönngren, Rassul Ayani, Richard M. Fujimoto, Samir R. Das
Venue: ACM SIGSIM Simulation Digest (1993)

The implementation of the pending event set (PES) is crucial to the execution speed of discrete event simulation programs. This paper studies the implementation of the PES in the context of simulations executing on parallel computers using the Time Warp mechanism. We present a scheme for implementing Time Warsp's PES based on well-known data structures for priority queues. This scheme supports efficient management of future and past events, especially for rollback and fossil collection operations. A comparative study of several queue implementations is presented. Experiments with a Time Warp system executing on a Kendall Square Research multiprocessor (KSR1) demonstrate that the implementation of the input queue can have a dramatic impact on performance, as large as an order of magnitude, that is much greater than what can be accounted for by simply the reduced execution time to access the data structure. In particular, it is demonstrated that an efficient input queue implementation can also significantly reduce the number of rollbacks, and the efficiency of memory management policies such as Jefferson's cancelback protocol. In the context of this work we also present an improved version of the skew heap that allows dequeueing of arbitrary elements at low cost. In particular, the possibility of dequeueing arbitrary elements will improve memory utilization. This ability is also important in applications where frequent rescheduling may occur, as in ready queues used to select the next logical process to execute.
Efficient simulation of caches under optimal replacement with applications to miss characterization
Authors: Rabin A. Sugumar, Santosh G. Abraham
Venue: ACM SIGMETRICS Performance Evaluation Review (1993)

Cache miss characterization models such as the three Cs model are useful in developing schemes to reduce cache misses and their penalty. In this paper we propose the OPT model that uses cache simulation under optimal (OPT) replacement to obtain a finer and more accurate characterization of misses than the three Cs model. However, current methods for optimal cache simulation are slow and difficult to use. We present three new techniques for optimal cache simulation. First, we propose a limited lookahead strategy with error fixing, which allows one pass simulation of multiple optimal caches. Second, we propose a scheme to group entries in the OPT stack, which allows efficient tree based fully-associative cache simulation under OPT. Third, we propose a scheme for exploiting partial inclusion in set-associative cache simulation under OPT. Simulators based on these algorithms were used to obtain cache miss characterizations using the OPT model for nine SPEC benchmarks. The results indicate that miss ratios under OPT are substantially lower than those under LRU replacement, by up to 70% in fully-associative caches, and up to 32% in two-way set-associative caches.
The career outlooks of I/S professionals
Authors: Ephraim R. McLean, John R. Tanner, Stanley J. Smits
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)

This follow-up study contrasted the pre-graduation and post-employment job characteristic preferences vs. realities of a sample of 290 I/S professionals. The preference-reality job characteristic discrepancies, job and career attitudes at follow-up, and two moderating variables (I/S salary level and length of I/S employment) became the independent variables in a multiple regression equation with present and long-term I/S career outlook as the dependent variables. The 16 independent variables had a significant impact on both present and long-term I/S career outlook (p < .00001). The reality shock experienced by entering I/S professionals and its impact on career outlook are discussed.
A New Class of Optimal Bounded-Degree VLSI Sorting Networks
Authors: Hussein M. Alnuweiri
Venue: IEEE Transactions on Computers (1993)

Minimum-area very large scale integration (VLSI) networks have been proposed for sorting N elements in O(log,N) time. However, most of such networks proposed have complex structures, and no explicit network construction is given in others. New designs of optimal VLSI sorters that combine rotate-sort with enumeration-sort to sort N numbers, each of length w (1+ in )logN bits (for any constant in
The CD-ROM foster a new data structure: the B3-tree
Authors: Alan L. Tharp, John L. Furlani
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

New technology and new applications often demand new data structures or modifications to existing ones. The CD-ROM is a relatively new technology that provides a very inexpensive storage medium. But it also has the disadvantage of being a read-only medium. This paper introduces the B3-tree, a modification of the popular B-tree. The B3-tree is intended to capture the advantages of the B+-tree with the cost benefits associated with using a CD-ROM. The 3 indicates that the B3-tree uses the three levels of memory hierarchy: primary memory, read-write secondary storage, and the CD-ROM. After describing the workings of the B3-tree, we give test results to illustrate its effectiveness under many conditions.
A domain-specific software architecture engineering process outline
Authors: Will Tracz, Lou Coglianese, Patrick Young
Venue: ACM SIGSOFT Software Engineering Notes (1993)

One of the dilemmas that has prevented software developers from resuing software is the lack of software artifacts to use or the existence of artifacts that are difficult to integrate. Domain-Specific Software Architectures (DSSAs) have been proposed[4] in order to address these issues. A DSAA not only provides a framework for reusable software components to fit into, but captures the design rationale and provides for a degree of adaptability. This paper1 presents an outline for a Domain-Specifid Software Architecture engineering process.
Interprocedural constant propagation: a study of jump function implementation
Authors: Dan Grove, Linda Torczon
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

An implementation of interprocedural constant propagation must model the transmission of values through each procedure. In the framework proposed by Callahan, Cooper, Kennedy, and Torczon in 1986, this intraprocedural propagation is modeled with a jump function. While Callahan et al. propose several kinds of jump functions, they give no data to help choose between them. This paper reports on a comparative study of jump function implementations. It shows that different jump functions produce different numbers of useful constants; it suggests a particular function, called the pass-through parameter jump function, as the most cost-effective in practice.
The productivity paradox; Why hasn't information technology fulfilled its promise?: a panel report from CSCW'92
Authors: David Constant
Venue: ACM SIGCHI Bulletin (1993)

Has information technology failed to Fulfill its promise of significant productivity improvements for industry and for the economy as a whole? If so, what has prevented it and what are the implications for CSCW design and deployment? These questions were addressed by a standing-room-only panel discussion of "The Productivity Paradox" at CSCW'92. The dis- cussion focused on Attewell's paper "Information Technology and the Productivity Paradox". The paper argues that, despite huge investment, the expected huge productivity improvements due to information technology have not been realized. The paper proposes several reasons why. Over the last three years this paper and the issues it raises have generated much controversy and passionate reaction in industry, academia and government.
Object oriented programming and virtual functions in conventional languages (an extended abstract)
Authors: Henrik Johansson
Venue: ACM SIGAda Ada Letters (1993)

The Ada language can be used as an object oriented language with simulated multiple inheritance and late binding, if only some simple programming rules stated here are used. This enhances the possiblities of code reuse without violation of the strict type checking in the language. The dependencies between separate compilable libarary units can be reduced to a minimum, which is a major obstacle for writing reusable Ada code.
Participation in computer security grew in '92
Authors: Lee Ohringer
Venue: ACM SIGSAC Review (1992)

Last November, many SIGSAC members celebrated Thanksgiving in different ways. Some may have even given thanks that their computers performed well during the previous year. A few days later, on December 1, which was the fifth annual ACM Computer Security Day, many of us were taking steps to assure that we would have better computer security during the upcoming year.
Bending and Creasing Virtual Paper
Authors: Yannick L. Kergosien, Hironobu Gotoda, Tosiyasu L. Kunii
Venue: IEEE Computer Graphics and Applications (1994)

We developed a mathematical model to simulate the bending and creasing behavior of paper-like sheets. This model permits interactive deformation of a surface remaining isometric to a plane rectangular sheet. It exhibits some important characteristics of paper behavior, such as the appearance of creases for some shapes of the boundary. Accurately simulating the detailed behavior of paper creases would involve several complex tasks, like employing mechanical shell modeling with possible boundary layer phenomena and studying the dynamics of buckling, or considering paper's plasticity. We do not discuss these difficult problems, instead simply analyzing the creasing phenomenon as a transition between two kinds of applicable surfaces.
Complete proof systems for algebraic simply-typed terms
Authors: Stavros S. Cosmadakis
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

We show that reasoning by case analysis (on whether subprograms diverge or converge) is complete for proving PCF observational congruences of algebraic terms. The latter are applicative combinations of first-order variables and a constant &OHgr; denoting a diverging program of base type. A restricted version of the logic is complete for proving equality of algebraic terms in the full continuous type hierarchy (equivalently, observational congruence in PCF with parallel conditional). We show that the provability in the latter logic is in co-NP. We also give complete equational proof systems for a subclass of algebraic terms; provability in these systems is in linear time.
The design and management of C++ class libraries (abstract)
Authors: Arthuir Riel
Venue: ACM SIGPLAN OOPS Messenger (1993)

The Design and Management of C++ Class Libraries Arthuir Riel, Vanguard Training Producing reusable C++ class libraries takes more than just knowing the language: it requires careful design. This tutorial shows how to create truly reusable C++ class libraries. It includes how to design a minimal public interface, variable-size objects, memory leakage, heuristics for operator overloading, designing reusable base-classes, using inheritance and containment, and deciding how to place classes in a class library.
Decompilation: the enumeration of types and grammars
Authors: Peter T. Breuer, Jonathan P. Bowen
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1994)

While a compiler produces low-level object code from high-level source code, a decompiler produces high-level code from low-level code and has applications in the testing and validation of safety-critical software. The decompilation of an object code provides an independent demonstration of correctness that is hard to better for industrial purposes (an alternative is to prove the compiler correct). But, although compiler compilers are in common use in the software industry, a decompiler compiler is much more unusual.It turns out that a data type specification for a programming-language grammar can be remolded into a functional program that enumerates all of the abstract syntax trees of the grammar. This observation is the springboard for a general method for compiling decompilers from the specifications of (nonoptimizing) compilers.This paper deals with methods and theory, together with an application of the technique. The correctness of a decompiler generated from a simple occam-like compiler specification is demonstrated. The basic problem of enumerating the syntax trees of grammars, and then stopping, is shown to have no recursive solution, but methods of abstract interpretation can be used to guarantee the adequacy and completeness of our technique in practical instances, including the decompiler for the language presented here.