ppxscal/embedding_network huggingface dataset:
Mapping the Interface Description Language Type Model into C
Authors: K. Shannon, Richard Thomas Snodgrass
Venue: IEEE Transactions on Software Engineering (1989)

The Interface Description Language (IDL) is a notation for describing the characteristics of data structures passed among collections of cooperating processes in a programming environment. The authors discuss a mapping from IDL to C data structures and macro definitions that supports the full language and is type safe and run-time efficient, but is not particularly compile-time efficient nor easy to use. They then propose that the mapping be performed in a preprocessor, thereby achieving efficiency and ease of use as well.
An efficient algorithm for hidden surface removal
Authors: K. Mulmuley
Venue: Proceedings of the 16th annual conference on Computer graphics and interactive techniques (1989)

We give an efficient, randomized hidden surface removal algorithm, with the best time complexity so far. A distinguishing feature of this algorithm is that the expected time spent by this algorithm on junctions which are at the "obstruction level" l, with respect to the viewer, is inversely proportional to l. This provably holds for any input, regardless of the way in which faces are located in the scene, because the expectation is with respect to randomization in the algorithm, and does not depend on the input. In practice, this means that the time complexity is roughly proportional to the size of the actually visible output times logarithm of the average depth complexity of the scene (this logarithm is very small generally).
Application performance improvement on the iPSC/2 computer
Authors: S. Arshi, R. Asbury, J. Brandenburg, D. Scott
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

The performance of concurrent computers depends fundamentally on the capabilities of the individual processing nodes and the characteristics of the interprocessor communication system. The Intel iPSC&reg;/2 is significantly better in both categories than the original iPSC (iPSC/1). This paper will briefly compare the hardware of the two machines and then discuss the actual measured performance improvement of several kernels of application codes. The improvements vary from a factor of two and a half to more than a factor of 30.
An Efficient Distributed Protocol for Finding Shortest Paths in Networks with Negative Weights
Authors: K. B. Lakshmanan, K. Thulasiraman, M. A. Comeau
Venue: IEEE Transactions on Software Engineering (1989)

The design is discussed of distributed algorithms for the single-source shortest-path problem to run on an asynchronous directed network in which some of the edges may be associated with negative weights, and thus in which a cycle of negative total weight may also exist. The only existing solution in the literature for this problem is due to K.M. Chandy and J. Misra (1982), and it has, in the worst case, an unbounded message complexity. A synchronous version of the Chandy-Misra algorithm is described and studied, and it is proved that for a network with m edges and n nodes, the worst case message and time complexities of this algorithm are O(mn) and O(n), respectively. This algorithm is then combined with an efficient synchronizer to yield an asynchronous protocol that retains the same message and time complexities.
The family of concurrent logic programming languages
Authors: Ehud Shapiro
Venue: ACM Computing Surveys (CSUR) (1989)

Concurrent logic languages are high-level programming languages for parallel and distributed systems that offer a wide range of both known and novel concurrent programming techniques. Being logic programming languages, they preserve many advantages of the abstract logic programming model, including the logical reading of programs and computations, the convenience of representing data structures with logical terms and manipulating them using unification, and the amenability to metaprogramming. Operationally, their model of computation consists of a dynamic set of concurrent processes, communicating by instantiating shared logical variables, synchronizing by waiting for variables to be instantiated, and making nondeterministic choices, possibly based on the availability of values of variables. This paper surveys the family of concurrent logic programming languages within a uniform operational framework. It demonstrates the expressive power of even the simplest language in the family and investigates how varying the basic synchronization and control constructs affect the expressiveness and efficiency of the resulting languages. In addition, the paper reports on techniques for sequential and parallel implementation of languages in this family, mentions their applications to date, and relates these languages to the abstract logic programming model, to the programming language PROLOG, and to other concurrent computational models and programming languages.
Event synchronization analysis for debugging parallel programs
Authors: P. A. Emrath, S. Chosh, D. A. Padua
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

One of the major difficulties of explicit parallel programming for a shared memory machine model is detecting the potential for nondeterminacy and identifying its causes. There will often be shared variables in a parallel program, and the tasks comprising the program may need to be synchronized when accessing these variables. This paper discusses this problem and presents a method for automatically detecting non-determinacy in parallel programs that utilize event style synchronization instructions, using the Post, Wait, and Clear primitives. With event style synchronization, especially when there are many references to the same event, the difficulty lies in computing the execution order that is guaranteed given the synchronization instructions and the sequential components of the program. The main result in this paper is an algorithm that computes such an execution order and yields a Task Graph upon which a nondeterminacy detection algorithm can be applied. We have focused on events because they are a frequently used synchronization mechanism in parallel versions of Fortran, including Cray [Cray87], IBM [IBM88], Cedar [GPHL88], and PCF Fortran [PCF88].
Parallel depth-first search in general directed graphs
Authors: A. Aggarwal, R. J. Anderson, M.-Y. Kao
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

A directed cycle separator of an n-vertex directed graph is a simple directed cycle such that when the vertices of the cycle are deleted, the resulting graph has no strongly connected component with more than n/2 vertices. This paper shows that the problem of finding a directed cycle separator is in randomized NC. The paper also proves that computing cycle separators and conducting depth-first search in directed graphs are deterministic NC-equivalent. These two results together yield the first RNC algorithm for depth-first search in directed graphs.
Modes survey results
Authors: J. Johnson, G. Engelbeck
Venue: ACM SIGCHI Bulletin (1989)

Though user-interface researchers and designers give similar definitions for the concept of modes in interactive systems and devices, informal evidence suggests that they don't always agree on whether or not particular interfaces are moded. A survey was conducted to determine the extent to which this is true. The results show that there is widespread disagreement among UI designers and researchers about what modes are, independent of the issue of how modes affect users.
Teaching practical software maintenance skills in a software engineering course
Authors: J. S. Collofello
Venue: Proceedings of the twentieth SIGCSE technical symposium on Computer science education (1989)

The typical one-semester software engineering course is normally geared towards new software development. Unfortunately, most new computer science graduates do not find themselves in a position where they are developing new software but instead in a position where they are maintaining an existing product. This paper describes some current practical software maintenance approaches which can be taught as a part of a software engineering course.
A graphical programming language interface for an intelligent LISP tutor
Authors: B. J. Reiser, P. Friedmann, J. Gevins, D. Y. Kimberg, M. Ranney
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

We describe an intelligent tutor for programming embedded in a graphical programming language. The tutor monitors students' problem solving and provides feedback and guidance. Explanations are generated from the content of the ideal model's problem solving rules. The graphical interface is designed to facilitate the acquisition of causal models of programming. Students work in a medium that corresponds to their planning operations. The interface enables forward and backward chaining, thus conveying the structure of the planning more effectively than a text-based interface. The interface also provides a graphical record of the solution history and current goals.
Algebraic specification of Macintosh's Quickdraw using OBJ2
Authors: A. T. Nakagawa, K. Futatsugi, S. Tomura
Venue: Proceedings of the 10th international conference on Software engineering (1988)

We have described QuickDraw, a typical graphics package, using OBJ2, a powerful algebraic language now in the phase of experimental use as a specification language. The results testify the applicability of OBJ2 to some practical problem domains, as well as the premonitioned advantages the use of formal specification techniques brings. The work also sheds some critical lights upon the design of QuickDraw; we detect incomplete procedure definitions, and find imprecise the classification of procedures.
Hardware acceleration for Window systems
Authors: D. Rhoden, C. Wilcox
Venue: ACM SIGGRAPH Computer Graphics (1989)

Graphics pipelines are quickly evolving to support multitasking workstations. The driving force behind this evolution is the window system, which must provide high performance graphics within multiple windows, while maintaining interactivity. The virtual graphics system presented by [7] provides a clean solution to the problem of context switching graphics hardware between processes, but does not solve all the problems associated with sharing graphics pipelines.The primary difficulty in context switching a graphics accelerator is the pipeline latency encountered during a pipeline flush. This latency removes the responsiveness and interactivity of the graphics system. As primitives become more complex and pipelines become longer, pipeline latency grows. Hardware solutions are described which further accelerate the window system by eliminating the need for pipeline flushing and resynchronization. An overview of the entire system is presented, highlighting the hardware mechanisms which contribute to window acceleration.
Strength guided motion
Authors: Philip Lee, Susanna Wei, Jianmin Zhao, Norman I. Badler
Venue: Proceedings of the 17th annual conference on Computer graphics and interactive techniques (1990)

A methodology and algorithm are presented that generate motions imitating the way humans complete a lifting task under various loading conditions. The path taken depends on "natural" parameters: the figure geometry, the given load, the final destination, and, especially, the strength model of the agent. Additional user controllable parameters of the motion are the comfort of the action and the perceived exertion of the agent. The algorithm uses this information to incrementally compute a motion path of the end-effector moving the load. It is therefore instantaneously adaptable to changing force, loading, and strength conditions. Various strategies are used to model human behavior (such as reducing moment, pull back, add additional joints, and jerk) that compute the driving torques as the situation changes. The strength model dictates acceptable kinematic postures. The resulting algorithm offers torque control without the tedious user expression of driving forces under a dynamics model. The algorithm runs in near-realtime and offers an agent-dependent toolkit for fast path prediction. Examples are presented for various lifting tasks, including one-and two-handed lifts, and raising the body from a seated posture.
LASSIE: structure to layout for behavioral synthesis tools
Authors: M. T. Trick, S. W. Director
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

Behavioral synthesis tools generate a wide range of designs, not all suited to one layout style. Thus there is a need for a flexible framework for mapping behavioral synthesis output onto module generators and layout tools. LASSIE provides this flexible framework and introduces a structural binding step that adapts the output of behavioral synthesis tools to different layout styles. The design process is divided into structural binding, partitioning, placement, and layout generation. Several options are provided at each step, and feedback is provided to the user to allow him to evaluate the results of each step.
Data buffer performance for sequential Prolog architectures
Authors: E. Tick
Venue: ACM SIGARCH Computer Architecture News (1988)

Several local data buffers are proposed and measurements are presented for variations of the Warren Abstract Machine (WAM) architecture for Prolog. Choice point buffers, stack buffers, split-stack buffers, multiple register sets, copyback caches, and &ldquo;smart&rdquo; caches are examined. Statistics collected from four benchmark programs indicate that small conventional local memories perform quite well because of the WAM's high locality. The data memory performance results are equally valid for native code and reduced instruction set implementations of Prolog.
File directory transmission via electronic mail
Authors: M. F. Wyle
Venue: ACM SIGUCCS Newsletter (1988)

A portable program to package, compress, document, transmit, and re-assemble multiple files in a B-tree directory structure is presented. The program preserves the structure, mode, protection, ownership, and integrity of all files and subdirectories. The algorithm and implementation are described in detail.
Bottom-up beats top-down for datalog
Authors: J. D. Ullman
Venue: Proceedings of the eighth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1989)

We show that for any safe datalog program P1 and any query Q (predicate of P1 with some bound arguments), there is another safe datalog program P2 that produces the answer to Q and takes no more time when evaluated by semi-naive evaluation than when P1 is evaluated topdown.
Forcing the completion of abnormal tasks
Authors: D. Papay
Venue: ACM SIGAda Ada Letters (1989)

The abort statement is used to bring about the unconditional completion of one or more tasks. However, some tasks are not required to become complete immediately upon execution of the abort statement and can continue to execute, perhaps indefinitely. While the use of forced synchronization points will bring about the completion of such tasks, they can produce undesirable run-time behavior in "normal" tasks. This paper presents an alternative to unconditional forced synchronization that allows abnormal tasks to become complete, but does not interfere with normal tasks.
Lattice gauge theory on the hypercube
Authors: J. Flower, J. Apostolakis, C. Baillie, H-Q. Ding
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

Lattice gauge theory, an extremely computationally intensive problem, has been run successfully on hypercubes for a number of years. Herein we give a flavor of this work, discussing both the physics and the computing behind it.
An improved Las Vegas primality test
Authors: E. Kaltofen, T. Valente, N. Yui
Venue: Proceedings of the ACM-SIGSAM 1989 international symposium on Symbolic and algebraic computation (1989)

We present a modification of the Goldwasser-Kilian-Atkin primality test, which, when given an input n, outputs either prime or composite, along with a certificate of correctness which may be verified in polynomial time. Atkin's method computes the order of an elliptic curve whose endomorphism ring is isomorphic to the ring of integers of a given imaginary quadratic field Q(&radic;&mdash;D). Once an appropriate order is found, the parameters of the curve are computed as a function of a root modulo n of the Hilbert class equation for the Hilbert class field of Q(&radic;&mdash;D). The modification we propose determines instead a root of the Watson class equation for Q(&radic;&mdash;D) and applies a transformation to get a root of the corresponding Hilbert equation. This is a substantial improvement, in that the Watson equations have much smaller coefficients than do the Hilbert equations.
Selecting simulation software for manufacturing applications
Authors: Averill M. Law, S. W. Haider
Venue: Proceedings of the 21st conference on Winter simulation (1989)

The number of simulation packages available for performing manufacturing analyses has grown tremendously during the past five years, making it increasingly more difficult for an analyst to choose simulation software for a particular application. In this paper, we present a set of features which should be considered when evaluating simulation software, and also a four-step selection strategy.
MODSIM II&mdash;an object oriented simulation language for sequential and parallel processors
Authors: O. F. Bryan,  Jr.
Venue: Proceedings of the 21st conference on Winter simulation (1989)

MODSIM II is an object-oriented general purpose and simulation language designed to work with both sequential and parallel processors. Its objects have both single and multiple inheritance.It has a single syntax that works across a variety of systems including main frames, work stations and PC's. A parallel version is currently under development on the BBN Butterfly parallel computer under the Time Warp operating system.MODSIM II is based on the syntax of Modula-2. The majority of statements are identical with those in Modula-2. It has a few additional constructs that let the user write discrete process simulations.MODSIM II has built-in object oriented constructs, including single and multiple inheritance, data abstraction and information hiding. In addition, it supports separate compilation. This makes it useful for large projects.It contains interactive dynamic graphics to improve input and output.
Issues and threats affecting timesharing and microcomputer sales
Authors: Robert Gillespie, Patrick Gossman
Venue: ACM SIGUCCS Newsletter (1988)

This article is aimed at acquainting members of the higher education community with current national and state issues affecting university timesharing and personal computer resales. Many universities have been selling computer services for a number of years. More recently they have seen the need for computer resales in order to carry out the key academic objectives supported by the introduction of computers on campuses. These resales have allowed advantageous prices for faculty, staff and students as well as the opportunity for imposing some standards which support network and instructional use. However, many for-profit timesharing services and computer retailers see the timesharing sales and resale of computers by colleges and universities as a competitive threat.
The structure and content of APL data
Authors: D. Landaeta
Venue: ACM SIGAPL APL Quote Quad (1989)

The complementary data attributes of structure and content are analyzed. Two special classes of functions, structural and pervasive, are defined in terms of their actions on these attributes. As an application of the definitions, a proposal is made for a modification to the nature of fill items and empty arrays.
Decentralized Decision-Making for Task Reallocation in a Hard Real-Time System
Authors: J. A. Stankovic
Venue: IEEE Transactions on Computers (1989)

A decentralized task reallocation algorithm for hard real-time systems is developed and analyzed. The algorithm, which is fast and reliable, specifically considers deadlines of tasks, attempts to utilize all the nodes of a distributed system to achieve its objective, handles tasks in priority order, and separates policy and mechanism. An extensive performance analysis of the algorithm by means of simulation shows that it is quite effective in performing reallocations and that it is significantly better than a centralized approach.
On Distributed Fault Simulation
Authors: Tassos Markas, Mark Royals
Venue: Computer (1990)

The authors examine the computational aspects of fault simulation of digital circuits and address issues related to the efficient partitioning of a fault simulation task to a number of subtasks assignable for execution to the nodes of a distributed system. They review the basic concepts involved in the operation of fault simulation. They describe the implementation of a distributed fault simulation facility, called DFSim, using a heterogeneous local area network consisting of a number of workstations with different computing resources and different versions of Unix operating systems.
Yesterday, I knew all the answers
Authors: L. Downing, S. Chambers
Venue: Proceedings of the 17th annual ACM SIGUCCS conference on User Services (1989)

A long time ago and far away in another world you discovered computing. It was fun and you enjoyed working with it. You felt comfortable using computers and software. Maybe you were a student or even a staff person when you decided to find a way to spend more time with computer technology. You applied for a job in User Services. You got the job and became part of an organization that dealt with computing all the time. Your responsibilities required you to learn more and more about computing and you found you enjoyed doing this. Then you were assigned the responsibility of helping customers directly. The customers liked you and you responded well to their questions. The customers got good answers and you felt really satisfied with your job. The job was becoming even better! Management liked what they saw you doing and expanded your responsibilities. You saw the new responsibilities as encouragement to do even more and better things. You accepted the challenges and took on the new tasks. You were able to handle the new responsibilities well which lead you to even more interaction with customers. You were now getting so good helping customers that you were asked to put together a training class, which you did. You discovered you liked teaching and helping several customers at one time. You developed another class, and then another and in doing so learned even more. You were now making a name for yourself and customers were seeking you out. The other User Services' staff started coming to you for help with their problems. You liked this attention and to make sure you didn't loose your new found importance you worked even harder at solving problems and learning new pieces of the technology. You were on a roll! You had found your niche!
Coping with ongoing knowledge acquisition from collaborating hierarchies of experts
Authors: B. G. Silverman, R. G. Wenig, T. Wu
Venue: Issue 108 (April 1989) (1989)

The Knowledge Elicitation System (ELI 2) and its predecessor (ELI 1) have been in use for about three years and have developed knowledge bases for about a dozen expert systems thus far. ELI interviews experts to uncover domain issues, criteria, heuristics, constraints, models, data bases, antecedent tradeoff possibilities and importance weights, and certainty factor estimates. It helps construct rapid prototypes, but more importantly it helps manage the growth and maintenance of large heterogeneous knowledge bases over extended periods of time.