ppxscal/embedding_network huggingface dataset:
Architecture synthesis of high-performance application-specific processors
Authors: Mauricio Breternitz,  Jr., John Paul Shen
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

The key principles of the Application-Specific Processor Design (ASPD) methodology include: a semi-custom compilation-driven design/implementation approach, the exploitation of fine-grained parallelism for high performance, and the adaptation of datapath topology to the data transfers required by the application. The powerful microcode compilation techniques of Percolation Scheduling and Pipeline Scheduling extract and enhance the parallelism in the application object code to generate an optimized specification of the target processor. Implementation optimization is performed to allocate functional units and register files. Graph-coloring algorithms minimize the amount of hardware needed to exploit available parallelism. Data memory employs an organization with multiple banks. Compilation techniques are used to allocate data over the memory banks to enhance parallel access.
The method of creative telescoping
Authors: Doron Zeilberger
Venue: Journal of Symbolic Computation (1991)

An algorithm for definite hypergeometric summation is given. It is based, in a non-obvious way, on Gosper's algorithm for definite hypergeometric summation, and its theoretical justification relies on Bernstein's theory of holonomic systems.
Touchscreen field specification for public access database queries: let your fingers do the walking
Authors: Andrew Sears, Yoram Kochavy, Ben Shneiderman
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

Database query is becoming a common task in public access systems; touchscreens can provide an appealing interface for such a system. This paper explores three interfaces for constructing queries on alphabetic field values with a touchscreen interface; including a QWERTY keyboard, an Alphabetic keyboard, and a Reduced Input Data Entry (RIDE) interface. The RIDE interface allows field values to be entered with fewer &ldquo;keystrokes&rdquo; (touches) than either keyboard while eliminating certain errors. In one test database, the RIDE interface required 69% fewer keystrokes than either keyboard interface.
The logic of the whole truth
Authors: Joseph S. Fulda
Venue: ACM SIGART Bulletin (1992)

This paper uses erotetic logic to characterize the legal concept of "the whole truth" sworn to by witnesses offering testimony. Such a model has potential application to expert systems for detecting perjury or gauging the severity of an instance of perjury. In addition, the model developed here has potential application to intelligent databases.
Sources of unbounded priority inversions in real-time systems and a comparative study of possible solutions
Authors: Sadegh Davari, Lui Sha
Venue: ACM SIGOPS Operating Systems Review (1992)

In the design of real-time systems, tasks are often assigned priorities. Preemptive priority driven schedulers are used to schedule tasks to meet the timing requirements. Priority inversion is the term used to describe the situation when a higher priority task's execution is delayed by lower priority tasks. Priority inversion can occur when there is contention for resources among tasks of different priorities. The duration of priority inversion could be long enough to cause tasks to miss their deadlines. Priority inversion cannot be completely eliminated. However, it is important to identify sources of priority inversion and minimize the duration of priority inversion. IN the paper we present a comprehensive review of the problem of and solutions to unbounded priority inversion.
Assembler utility functions for APL2/PC
Authors: Tauno Ylinen
Venue: Proceedings of the international conference on APL '91 (1991)

Some general guidelines are discussed on why and how to develop utility functions in assembler for the APL2/PC environment. Assembler utility functions may replace some most heavily used idiomatic APL auxiliary functions and boost the efficiency of APL applications. About twenty such functions are presented, some of them perhaps useful as temporary extensions of the APL2/PC interpreter. The collection of assembler utility functions is available in the public domain, and should be extended by the joint efforts of the international APL community.
Finite-model theory&mdash;a personal perspective
Authors: Ronald Fogin
Venue: Proceedings of the third international conference on database theory on Database theory (1990)

This paper is a very personalized view of finite-model theory, where the author focuses on his own personal history, and results and problems of interest to him, especially those springing from work in his Ph.D. thesis. No attempt is made to be comprehensive.
Digital halftoning with space filling curves
Authors: Luiz Velho, Jonas de Miranda Gomes
Venue: Proceedings of the 18th annual conference on Computer graphics and interactive techniques (1991)

This paper introduces a new digital halftoning technique that uses space filling curves to generate aperiodic patterns of clustered dots. This method allows the parameterization of the size of pixel clusters, which can vary in one pixel steps. The algorithm unifies, in this way, the dispersed and clustered-dot dithering techniques.
Developing expertise in expert system development by developing prototypes for actual commercial applications
Authors: Lawrence J. Mazlack, Roger A. Pick, Paul Tudor, Wallace R. Wood
Venue: Proceedings of the twenty-third SIGCSE technical symposium on Computer science education (1992)

We designed and executed a course to develop expert system expertise in a classroom environment. It taught both the theory and practice of knowledge-based systems. Teams consisted of knowledge domain experts and computer experienced people. The interest was training people in knowledge-base tasks and having them develop commercially significant projects. The focust of this paper is on what was done in the classroom to provide a significant expert system development experience.
The Estimation of Parameters of the Hypergeometric Distribution and its Application to the Software Reliability Growth Model
Authors: Yoshihiro Tohma, Hisashi Yamano, Morio Ohba, Raymond Jacoby
Venue: IEEE Transactions on Software Engineering (1991)

Six ways to estimate parameters of the hypergeometric distribution are investigated, and their accuracies are examined comparatively. It is demonstrated that the least-squares sum method is the best one among those tried, and can be applied to real test/debug data for estimating the number of faults still resident in a program after test/debugging. By this method the estimation time can be reduced greatly.
A cost-effective reliable multipath interconnection network
Authors: Todd D. Morris, Edward F. Gehringer
Venue: ACM SIGARCH Computer Architecture News (1991)

A new class of multistage interconnection networks is proposed. A network in this class consists of a standard multistage network, such as an omega network, augmented by multiplexers at the source nodes and demultiplexers at the destination. In addition, the first several stages are capable of adapting their routing decisions to avoid faults elsewhere in the network. The terminal reliability of this network is derived, and it is shown to have superior reliability, at a much lower cost than previous networks of similar fault tolerance. It is demonstrated that the proposed network's probability of acceptance, a common measure of performance for circuit-switched networks, is comparable to other networks of similar cost, but the greater number of paths it provides between source and destination should give it better performance under non-uniform traffic conditions.
Massively distributed computing and factoring large integers
Authors: Robert D. Silverman
Venue: Communications of the ACM (1991)

Over the last 15 years the increased availability of computers and the introduction of the RSA cryptosystem has led to a number of new and remarkable algorithms for finding the prime factors of large integers. Factoring numbers is an arithmetic problem so simple to understand that school children are asked to do it. While multiplying or adding two very large numbers is simple and can be done quite quickly, the age-old problem of trying to find a number that divides another number still has no simple solution. Computer science has reached a point where it is starting to custom tailor the design of computers toward solving specific problems. This pracnique will discuss some of the more recent algorithms for factoring large numbers and how networks of computers can be used to run these algorithms quickly. Since this is a general exposition, we do not give detailed mathematical descriptions of the algorithms. We also allow ourselves to be somewhat casual with mathematical notation in places and hope that the mathematically sophisticated will forgive the looseness.
Rule condition testing and action execution in Ariel
Authors: Eric N. Hanson
Venue: ACM SIGMOD Record (1992)

This paper describes testing of rule conditions and execution of rule actions in Ariel active DBMS. The Ariel rule system is tightly coupled with query and update processing. Ariel rules can have conditions based on a mix of patterns, events, and transitions. For testing rule conditions, Ariel makes use of a discrimination network composed of a special data structure for testing single-relation selection conditions efficiently, and a modified version of the TREAT algorithm, called A-TREAT, for testing join conditions. The key modification to TREAT (which could also be used in the Rete algorithm) is the use of virtual &agr;-memory nodes which save storage since they contain only the predicate associated with the memory node instead of copies of data matching the predicate. The rule-action executor in Ariel binds the data matching a rule's condition to the action of the rule at rule fire time, and executes the rule action using the query processor.
Code reader
Authors: Vikas K. Kamat
Venue: ACM SIGSOFT Software Engineering Notes (1991)

Source code reading as an element of Software Engineering has long been ignored. Presented here is a pseudo-design of a Code reader (CREAD) for 'C' like language.
On dynamic Voronoi diagrams and the minimum Hausdorff distance for point sets under Euclidean motion in the plane
Authors: Daniel P. Huttenlocher, Klara Kedem, Jon M. Kleinberg
Venue: Proceedings of the eighth annual symposium on Computational geometry (1992)

We show that the dynamic Voronoi diagram of k sets of points in the plane, where each set consists of m points moving rigidly, has complexity O(n2k2&lgr;s(k)) for some fixed s, where &lgr;s(n) is the maximum length of a (n, s) Davenport-Schinzel sequence. This improves the result of Aonuma et al., who show an upper bound of O(n3k4 log* k) for the complexity of such Voronoi diagrams. We then apply this result to the problem of finding the minimum Hausdorff distance between two point sets in the plane under Euclidean motion. We show that this distance can be computed in time O((m + n)6 log (mn)), where the two sets contain m and n points respectively.
Epochs
Authors: Jon A. Solworth
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1992)

To date, the implementation of message passing languages has required hte communications variables (sometimes called ports) either to be limited to the number of physical communications registers in the machine or to be mapped to memory. Neither solution is satisfactory. Limiting the number of variables decreases modularity and efficiency of parallel programs. Mapping variables to memory increases the cost of communications and the granularity of parallelism. We present here a new programming language construct called epochs. Epochs are a scoping mechanism within which the programmer can declare communications variables, which are live only during the scope of that epoch. To limit the range of time a register has to be allocated for a communications variable, the compiler ensures that all processors enter an epoch simultaneously. The programming style engendered fits somewhere between the SIMD data parallel and the MIMD process spawning models. We describe an implementation for epochs including an efficient synchronization mechanism, a means of statically binding registers to communications variables, and a method of fusing epochs to reduce synchronization overhead.
Guidelines for the Documentation of Segments of the History of Computing
Authors: J. A. N. Lee
Venue: IEEE Annals of the History of Computing (1991)

Requirement specifications for the guidance of researchers in collecting and recording the history of computing have been sought by many persons during our 12 year history as a journal. While there does not exist a definitive outline which covers all aspects of the field, the set of guidelines created for the first History of Programming Languages Conference in 1976 have been used by many researchers, authors, and editors. This set of questions, primarily targeted toward those who were involved in the very history which they are recording and reporting on, has been revised and expanded by the program committee of the proposed second History of Programming Languages Conference, scheduled for 1993.
Higher Radix Square Root with Prescaling
Authors: Tomás Lang, Paolo Montuschi
Venue: IEEE Transactions on Computers (1992)

A scheme for performing higher radix square root based on prescaling of the radicand is presented to reduce the complexity of the result-digit selection. The scheme requires several steps, namely multiplication for prescaling the radicand, square root, multiplication for prescaling for the division, and division. Online algorithms are used to reduce the overall time and pipelining to reuse the different modules. An estimate of the execution time for a radix-256 unit for double-precision square root and a comparison with other implementations indicate that the proposed approach is an alternative to consider when designing a square-root unit.
Protocol analysis of a novice programmer
Authors: Catherine Bishop-Clark
Venue: ACM SIGCSE Bulletin (1992)

This study examined the problem solving of a novice programmer writing a first draft of an elementary computer program. The latter stages of entering and debugging the program were not part of the analysis. A detailed analysis of the tape-recorded protocol confirmed the major themes of the research on novice problem solving. Some characteristics specific to programming were also identified. In particular, the subject emphasized the syntax of the language, showed little advanced planning, and organized her programming information in the order it had been presented in class. There were distinct phases of (a) understanding the problem, (b) devising a plan, and (c) carrying out the plan. There was also evidence of both positive and negative transfer from what the student had previously learned in class. A number of practical guidelines for teaching novices to program emerged from the analysis and the literature.
A logic base tool set for real-time Ada software development
Authors: Michael Moore
Venue: Proceedings of the eighth annual Washington Ada symposium summer SIGAda meeting on Ada: software: foundation for competitveness (1991)

This is a report on work conducted privately that explores the use of predicate logic to reason about real-time design. Safety and reliability issues associated with embedded real-time systems make greater demands on development engineers than non-real-time systems whose functional complexity is of similar degree. The effort undertaken here attempts to provide methods and tools for dealing with both the functional and temporal aspects of software engineering. The goal is to improve the effectiveness of engineering and thus the productivity of a development team. The problem was approached using a variant of the IDEFO (SADT) modeling methodology, an adaptation equipped with primitives for expressing data types, time constraints, and process activation rules. The SADT methodology serves as the interface between an engineer and a &ldquo;deep structure&rdquo; representation of a system expressed using logic predicates. The SADT framework supports the modeling of a system with an arbitrary number of processing resources using hierarchical specifications of time constraints and resource utilization limitations. The concepts of resource utilization, period, as well as &ldquo;hard&rdquo; and &ldquo;soft&rdquo; deadline are built into the approach. This particular report describes a tool set that has been built using these concepts. The tools illustrate that the logic based models are sufficient for conduction control path analysis and schedulability analysis. An example is provided of tool capability in which schedulable entities are identified in the SADt model assigned priorities, and then are shown to be schedulable by application of the Critical Instant test. The associated PDL, annotated with time constraints is produced as well. All steps are automatic. Rate monotonic prioritization is selected for the example. Experience with the tools indicates that this is a practical cost effective approach to real-time systems engineering.
Computer classification of integrable coupled KdV-like systems
Authors: V. P. Gerdt, D. Yu. Zharkov
Venue: Journal of Symbolic Computation (1990)

The foundations of the symmetry approach to the classification problem of integrable non-linear evolution systems are briefly described. Within the framework of the symmetry approach the ten-parametric family of the third order non-linear evolution coupled KdV-like systems is investigated. The necessary integrability conditions lead to an over-determined non-linear algebraic system. To solve that system an effective method based on its structure has been used. This allows us to obtain the complete list of integrable systems of a given type. All computation has been completed on the basis of computer algebra systems FORMAC and REDUCE.
Sentential semantics for propositional attitudes
Authors: Andrew R. Haas
Venue: Computational Linguistics (1990)

The sentential theory of propositional attitudes is very attractive to AI workers, but it is difficult to use such a theory to assign semantics to English sentences about attitudes. The problem is that a compositional semantics cannot easily build the logical forms that the theory requires. We present a new notation for a sentential theory, and a unification grammar that builds logical forms in our notation. The grammar is implemented using the standard implementation of definite clause grammars in Prolog.
A GOMS analysis of a graphic machine-paced, highly interactive task
Authors: Bonnie E. John, Alonso H. Vera
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1992)

A GOMS analysis was used to predict the behavior of an expert in a graphic, machine-paced, highly interactive task. The analysis was implemented in a computational model using the Soar cognitive architecture. Using only the information available in an instruction booklet and some simple heuristics for selecting between operators, the functional-level behavior of the expert proved to be virtually dictated by the objects visible on the display. At the keystroke-level, the analysis predicted about 60% of the behavior, in keeping with similar results in previous GOMS research. We conclude that GOMS is capable of predicting expert behavior in a broader range of tasks than previously demonstrated.
Segmented channel routing
Authors: Jonathan Greene, Vwani Roychowdhury, Sinan Kaptanoglu, Abbas El Gamal
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

Routing channels in a field-programmable gate array contain predefined wiring segments of various lengths. These may be connected to the pins of the gates or joined end-to-end to form longer segments by programmable switches. The segmented channel routing problem is formulated, and polynomial time algorithms are given for certain special cases. The general problem is NP-complete, but it can be adequately solved in practice. Experiments indicate that a segmented channel with judiciously chosen segment lengths may near the efficiency of a conventional channel.
Using Harel statecharts to model object-oriented behavior
Authors: Neal Walters
Venue: ACM SIGSOFT Software Engineering Notes (1992)

Object-oriented analysis and design methods are increasingly being considered for complex system development. However, object-oriented implementations can introduce run-time inefficiencies. Therefore, predicting system behavior is an important simulation objective for validating completeness and analyzing performance. There are two contributors to system behavior - the individual behavior of each object and the collaborative behavior of object when executing scenarios required by the system. Modeling the collaborative interaction of objects is the primary subject of this paper. Templates for three types of objects are presented: Director, Agent and Server object classes. The mechanisms presented in this paper utilize Harel state diagram notation as supported by the Statemate CASE tool.
Does Modula-2 generate racehorses?: comparison of compiler generated code quality for floating point arithmetic
Authors: Günter Dotzel
Venue: ACM SIGPLAN Notices (1990)

A simple example serves to demonstrate the code quality generated by two different Modula-2 compilers. In this paper the two compilers are called the Z uuml;rich/Hamburger and the Erlanger.
Extended Horn sets in propositional logic
Authors: V. Chandru, J. N. Hooker
Venue: Journal of the ACM (JACM) (1991)

The class of Horn clause sets in propositional logic is extended to a larger class for which the satisfiability problem can still be solved by unit resolution in linear time. It is shown that to every arborescence there corresponds a family of extended Horn sets, where ordinary Horn sets correspond to stars with a root at the center. These results derive from a theorem of Chandresekaran that characterizes when an integer solution of a system of inequalities can be found by rounding a real solution in a certain way. A linear-time procedure is provided for identifying &ldquo;hidden&rdquo; extended Horn sets (extended Horn but for complementation of variables) that correspond to a specified arborescence. Finally, a way to interpret extended Horn sets in applications is suggested.
Tools for supporting the collaborative process
Authors: James R. Rhyne, Catherine G. Wolf
Venue: Proceedings of the 5th annual ACM symposium on User interface software and technology (1992)

Collaborative software has been divided into two temporal categories: synchronous and asynchronous. We argue that this binary distinction is unnecessary and harmful, and present a model for collaboration processes (i.e. the temporal record of the actions of the group members) which includes both synchronous and asynchronous software as submodels. We outline an object&ndash;oriented toolkit which implements the model, and present an application of its use in a pen&ndash;based conferencing tool.