ppxscal/embedding_network huggingface dataset:
Finiteness conditions for fixed point iteration
Authors: Flemming Nielson, Hanne Riis Nielson
Venue: Proceedings of the 1992 ACM conference on LISP and functional programming (1992)

This paper provides a link between the formulation of static program analyses using the framework of abstract interpretation (popular for functional languages and using the more classical framework of data flow anlysis (popular for imperative languages). In particular we show how the classical notions of fastness, rapidity and k-boundedness carry over to the abstract interpretation framework and how this may be used to bound the number of times a functional should be unfolded in order to yield the fixed point. This is supplemented with a number of results on how to calculate the bounds for iterative forms (as for tail recursion), for linear forms (as for one nested recursive call), and for primitive recursive forms. In some cases this improves the &ldquo;worst case&rdquo; results of, but more importantly it gives much better&ldquo;average case&rdquo; results.
A scalable, object-oriented finite element solver for partial differential equations on multicomputers
Authors: Graham Carey, Joe Schmidt, Vineet Singh, Dennis Yelton
Venue: Proceedings of the 6th international conference on Supercomputing (1992)

We present a parallel finite element solver for mesh-connected multicomputers (ie., message-passing, distributed-memory multiprocessors) and provide a theoretical proof tht the algorithms used are highly scalable and close to optimal. Further, the algorithms are written in an object-oriented language (ESP C++) to enhance reusability of code. Performance results are presented for a Motorola multicomputer and a network of Sun workstations.
Proving probabilistic correctness statements: the case of Rabin's algorithm for mutual exclusion
Authors: Isaac Saias
Venue: Proceedings of the eleventh annual ACM symposium on Principles of distributed computing (1992)

The correctness of most randomized distributed algorithms is expressed by a statement of the form &ldquo;some predicate of the executions holds with high probability, regardless of the order in which actions are scheduled&ldquo;. In this paper, we present a general methodology to prove correctness statements of such randomized algorithms. Specifically, we show how to prove such statements by a series of refinements, which terminate in a statement independent of the schedule. To demonstrate the subtlety of the issue involved in this type of analysis, we focus on Rabin's randomized distributed algorithm for mutual exclusion [6]. Surprisingly, it turns out that the algorithm does not maintain one of the requirements of the problem under a certain schedule. In particular, we give a schedule under which a set of processes can suffer lockout for arbitrary long periods.
Concurrency Extraction Via Hardware Methods Executing the Static Instruction Stream
Authors: Augustus K. Uht
Venue: IEEE Transactions on Computers (1992)

Hardware solutions to low-level (semantic) concurrency extraction are presented, focusing on the reduction of both control-flow and dataflow inhibitors of concurrency in general-purpose and scientific instruction streams. In the first model, CONDEL-1, an input code control flow model based on the code's branch domains is used in the algorithm to detect the reduced procedural dependencies in the input code. This model allows branches to execute concurrently. The cost and delay of the model's concurrency hardware are demonstrated to be relatively low, especially for the detection of concurrency beyond branches. The reduced procedural dependence techniques of CONDEL-1 are combined with high-speed reduced data dependency techniques to yield a machine model, CONDEL-2, executing standard sequential code in a manner beyond data-flow. Simulation results are presented and analyzed, showing the model's functionality and performance improvement. The beneficial effects of limited software optimizations are also reviewed.
Case studies in the classroom
Authors: M. J. Clancy, M. C. Linn
Venue: Proceedings of the twenty-third SIGCSE technical symposium on Computer science education (1992)

We and others have created case studies to engage students in the process of designing solutions to complex programming problems. Case studies involve learners in activities of expert programmers such as identifying decisions, justifying choices among alternatives, and evaluating the consequences of these choices. Case studies improve computer programming courses by emphasizing the process rather than the product of problem solving. This paper describes specific uses of case studies in freshman and sophomore-level courses.
A foundation for an efficient multi-threaded scheme system
Authors: Suresh Jagannathan, Jim Philbin
Venue: Proceedings of the 1992 ACM conference on LISP and functional programming (1992)

We have built a parallel dialect of Scheme called STING that differs from its contemporaries in a number of important respects. STING is intended to be used as an operating system substrate for modern parallel programming languages. The basic concurrency management objects is STING are first-class lightweight threads of control and virtual processors (VPs). Unlike high-level concurrency structures, STING threads and VPs are not encumbered by complex synchronization protocols. Threads and VPs are manipualted in the same way as any other Scheme structure. STING separates thread policy decisions from thread implementation ones. Implementations of different parallel languages built on top of STING can define their own scheduling and migration policies without requiring modification to the runtime system or the provided interface. Process migration and scheduling can be customized by applications on a per-VP basis. The semantics and implementation of threads minimizes the cost of thread creation, and puts a premium on storage locality. The storage management policies in STING lead to better cache and page utilization, and allows users to experiment with a variety of different execution regimes&mdash;from fully delayed to completely eager evaluation.
Embedding meshes on the star graph
Authors: Sanjay Ranka, Jhychun Wang, Nangkang Yeh
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

We develop algorithms for mapping n-dimensional meshes on a star graph of degree n with expansion 1 and dilation 3. We show that an n-degree star graph can efficiently simulate an n-dimensional mesh.
Delay and area optimization in standard-cell design
Authors: Shen Lin, M. Marek-Sadowska, Ernest S. Kuh
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

This paper presents a heuristic approach to the optimal selection of standard cells in VLSI circuit design. We are considering a cell library composed of several templates (3-5) for each type of cell. These templates differ in area, driving capabilities, intrinsic delay, and capacitive loading. When realizing a logically synthesized circuit, we select the best templates from the cell library to minimize the total area of the cells under delay constraints. We have found a very successful heuristic approach to attack this discrete optimization problem. Experimental results show that this approach runs very fast, with the complexity of &Ogr;(n2), and improves the results obtained from the technology mapping of misII. [15]
Analyzing Hard-Real-Time Programs for Guaranteed Schedulability
Authors: Alexander D. Stoyenko, V. Carl Hamacher, Richard C. Holt
Venue: IEEE Transactions on Software Engineering (1991)

A set of language-independent schedulability analysis techniques is presented. Utilizing knowledge of implementation- and hardware-dependent information in a table-driven fashion, these techniques provide accurate worst-case time bounds and other schedulability information. A prototype schedulability analyzer has been developed to demonstrate the effectiveness of these techniques. The analyzer consists of a partially language-dependent front-end, targeted at real-time Euclid, a real-time language specifically designed with a set of schedulability analysis provisions built-in, and a language-dependent back-end. The analyzer has been used on a number of realistic real-time programs run on a multiple-microprocessor system. Predicted program performance differs only marginally from the actual performance.
Behavior of database production rules: termination, confluence, and observable determinism
Authors: Alexander Aiken, Jennifer Widom, Joseph M. Hellerstein
Venue: Proceedings of the 1992 ACM SIGMOD international conference on Management of data (1992)

Static analysis methods are given for determining whether arbitrary sets of database production rules are (1) guaranteed to terminate; (2) guaranteed to produce a unique final database state; (3) guaranteed to produce a unique stream of observable actions. When the analysis determines that one of these properties is not guaranteed, it isolates the rules responsible for the problem and determines criteria that, if satisfied, guarantee the property. The analysis methods are presented in the context of the Starburst Rule System; they will form the basis of an interactive development environment for Starburst rule programmers.
A simple TCP extension for high-speed paths
Authors: Zheng Wang, Jon Crowcroft, Ian Wakeman
Venue: ACM SIGCOMM Computer Communication Review (1992)

RFC-1072 and RFC-1185 have proposed a new TCP option "Echo/Echo Reply", in which timestamps are carried in TCP headers to aid in extending the sequence number space beyond 32 bits. However, such an extension will add an extra 64 bits to the TCP header and will require option processing for each packet at both ends. In this paper, we propose a simpler TCP extension that expands the sequence number space without increasing the size of the TCP header.
A practical online design rule checking system
Authors: Goro Suzuki, Yoshio Okamura
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

In this paper, we propose a practical online design rule checking system, which can provide the following features: an ability to cope with a complicated and wide variety of design rules with high accuracy, easy use, high speed incremental DRC (simultaneous checking with pattern editing) and total DRC (non-simultaneous checking), high speed pattern editing, and a small memory space. For the last three items, a field block data structure is developed. Experimental results show this system is very effective for VLSI cell layout design.
Binary wrapping: a technique for instrumenting object code
Authors: Jon Cargille, Barton P. Miller
Venue: ACM SIGPLAN Notices (1992)

We present a technique, called binary wrapping, that allows object code routines to be instrumented. Binary wrapping allows tracing to be placed around (and sometimes within) proprietary code, when source code access is difficult or impossible. This technique is based on wrapping user-written code around the object code routine. No modifications are needed to the programs that call the object code routine. Binary wrapping has proven itself invaluable in instrumenting proprietary libraries, and may well be useful in other similar circumstances.
Efficient Algorithms for the Instantiated Transitive Closure Queries
Authors: Ghassan Z. Qadah, Lawrence J. Henschen, Jung J. Kim
Venue: IEEE Transactions on Software Engineering (1991)

The performances of several algorithms suitable for processing an important class of recursive queries called the instantiated transitive closure (TC) queries are studied and compared. These algorithms are the wavefront, delta -wavefront, and a generic algorithm called super-TC. During the evaluation of a TC query, the first two algorithms may read a given disk page more than once, whereas super-TC reads the disk page at most once. A comprehensive performance evaluation of these three algorithms using rigorous analytical and simulation models is presented. The study reveals that the relative performance of the algorithms is a strong function of the parameters which characterize the processed TC query and the relation referenced by that query. The superiority of one of the super-TC variants over all of the other presented algorithms is shown.
A first computing course based on curricula 1991
Authors: Juan Alvarez Rubio
Venue: Proceedings of the twenty-third SIGCSE technical symposium on Computer science education (1992)

A two semester first year course is proposed that provides an introduction to algorithmic problem solving and programming, human-computer communication, file and database systems, and software engineering. The goals of this course coincide and expand upon the Introduction to Programming and Computer Tools course proposed by the ACM Task Force as a prerequisite for studies in computer science. The methodology integrates the contents of several knowledge units of the Computing Curricula 1991 of the ACM/IEEE-CS.
A guided tour of the Common Lisp interface manager
Authors: Ramana Rao, William M. York, Dennis Doughty
Venue: ACM SIGPLAN Lisp Pointers (1990)

The Common Lisp Interface Manager (CLIM) is a powerful Lisp-based system that provides a layered set of facilities for building user interfaces. These facilities include a portable layer called Silica that includes basic windowing, input, output services, and mechanisms for constructing window types and user interface components; stream-oriented input and output facilities extended with presentations and context sensitive input similar to the work pioneered in the Genera UI system; and a gadget-oriented toolkit similar to those found in the X world extended with support for look and feel adaptiveness. In this article, we present an overview of CLIM's broad range of functionality and present a series of examples that illustrates CLIM's power.
Parameterized specifications for software reuse
Authors: Jingwen Cheng
Venue: ACM SIGSOFT Software Engineering Notes (1992)

Software reusability is believed to be the key to improving software development productivity, while specification plays an important part in software reuse. From a modern object oriented view, the reusable software components can be grouped into three categories. Procedural components, abstract data types and concrete data objects. Both procedural components and abstract data types can be parameterized in many Object-Oriented languages. Specifications for reuse of these components are discussed in detail in this paper. The reusable software components and their specifications will form a reusable software library, and the information extracted from the specifications forms a knowledge base. Based on the knowledge base and the reusable software library, a new software development paradigm with software reusability can be realized.
Parameter passing: a window into students' views of programming (abstract)
Authors: Ann Fleury
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

One reason that Pascal is considered an appropriate introductory programming language for computer science majors is that Pascal permits the creation of modular programs by using logically independent procedures. However this advantage of Pascal is utilized only if students learn to manage parameter passing well enough to harness Pascal's power. In particular, students should learn to use the stylistic conventions accepted by the professional programming community and to understand the reasons for these conventions. This study examined student knowledge and beliefs relating to parameter passing in Pascal. During interviews, students were asked to predict which programs from a collection of similar programs would work according to specification and which would not work due to variable access errors or parameter passing errors. Also during interviews, students were asked to rate program versions on several stylistic criteria, including ease of comprehension, ease of debugging, and ease of modification. Programming experts were asked to rate the same program versions on the same criteria. This paper will discuss these inter-views. In particular students' views of the larger programming process will be discussed.
The KYKLOS Multicomputer Network: Interconnection Strategies, Properties, and Applications
Authors: Bernard L. Menezes, Roy Jenevein
Venue: IEEE Transactions on Computers (1991)

A tree-based interconnection architecture (called KYKLOS) for multicomputer systems is proposed. While the general form of the topology consists of multiple m-ary trees sharing a common set of leaf nodes, the focus is on the dual-tree case. One version of the dual-tree KYKLOS involves a bottom tree where the ordering of descendants of nodes at every level is an m-way shuffle. This architecture provides fault tolerance and vastly improved properties over the simple double tree while retaining the simplicity and low fan-out of the m-ary tree. Different routing strategies are presented and network properties as a function of routing strategy are investigated. The O(N/sup 2/) congestion at the root of the m-ary tree is reduced to O(N/sup 1.5/) while average normalized communication latencies are decreased. Applications of this architecture to facilitate parallel input/output (I/O) access and parallel processing of database operations such as the relational join are studied.
Effects of building blocks on the performance of super-scalar architecture
Authors: Edil S. T. Fernandes, Fernando M. B. Barbosa
Venue: Proceedings of the 19th annual international symposium on Computer architecture (1992)

The inherent low level parallelism of Super-Scalar architectures plays an important role in the processing power provided by these machines: independent functional units promote opportunities for executing several machine operations simultaneously. From the viewpoint of the hardware designer it is very important to assess the influence of each functional unit, and the way they communicate, on the overall performance of the machine. Particularly, it is highly desirable to determine an upper bound in the number of additional functional units which give significant performance improvement ratios. This work describes experiments that have been carried out to assess the effect of alternative instruction issue mechanisms, multiple functional units, instruction queues, common data bus and other hardware solutions on the performance of Super-Scalar machines. The assessment was obtained by interpreting non optimized object code fo an actual processor on some basic machine models. The paper outline the main aspects of the research, and shows that speed-up ratios of up to 3.35 times were observed during the interpretation of benchmark programs.
Automatic Test Pattern Generation with Branch Testing
Authors: Rafic Z. Makki, Silvio Bou-Ghazale, Chen Tianshang
Venue: IEEE Transactions on Computers (1991)

The authors present a test algorithm for finite state machines called branch testing. Based on branch testing, a design-for-test (DFT) method is proposed. Comparisons to other DFT methods show the method to be competitive relative to circuit overhead. A minimum set of paths containing all primary and internal gate-level input/output lines is found. Each of these paths is then sensitized so as to detect all single stuck-at faults. The authors demonstrated that the one-hot encoded FSMs can be easily and thoroughly tested via a simple algorithm. It is demonstrated that the use of scan paths is not necessary if a one-hot encoded state assignment is made. The synthesis and simulation resulting have shown that the package of one-hot encoding and branch testing constitutes a viable design and test approach.
Determining an Optimal Time Interval for Testing and Debugging Software
Authors: Nozer D. Singpurwalla
Venue: IEEE Transactions on Software Engineering (1991)

A decision-theoretic procedure for determining an optimal time interval for testing software prior to its release is proposed. The approach is based on the principles of decision-making under uncertainty and involves a maximization of expected utility. Two plausible forms for the utility function, one based on costs and the other involving the realized reliability of the software, are described. Using previous results on probabilistic models for software failure, the ensuing optimization problem (which can be addressed using numerical techniques) is outlined for the case of single-state testing. The sensitivity of the results to the various input parameters is discussed, and some directions for future research are outlined.
Generic text processing: a progress report
Authors: Paul S. Jacobs, George R. Krupka, Susan W. McRoy, Lisa F. Rau, Norman K. Sondheimer, Uri Zernik
Venue: Proceedings of the workshop on Speech and Natural Language (1990)

A generic natural language system, without modification, can effectively analyze an arbitrary input at least to the level of word sense tagging. Considerable research has addressed the <i>transportability</i> of natural language systems, but not <i>generic</i> text processing capabilities. For example, previous DARPA-sponsored work [1, 2] produced transportable interfaces to database systems. Each new application of these interfaces generally required modifications to lexicons, new semantic knowledge bases, and other specialized features. The most that natural language text processing systems have accomplished has been the parsing of arbitrary text, without any real semantic analysis.
Defining more efficient transfer syntax for application layer PDUs in field bus applications
Authors: Artur Cardoso, Eduardo Tovar
Venue: ACM SIGCOMM Computer Communication Review (1992)

This paper proposes a set of coding rules suitable for usage in the Field Bus Application Layer Services. The major considerations presented in this document were adopted as a working basis in the ESPRIT project 5206, FICIM (Field bus Integration into Computer Integrated Manufacturing). As an input from FICIM to the international standardization work, in particular to the ISA SP 50 / IEC 65C WG6 committees, this proposal was the object of a survey, and its adoption in the International Standard for Field Bus Networks is under discussion at the time of this writing.
Analysis of Concurrency-Coherency Control Protocols for Distributed Transaction Processing Systems with Regional Locality
Authors: Bruno Ciciani, Daniel M. Dias, Philip S. Yu
Venue: IEEE Transactions on Software Engineering (1992)

A system structure and protocols for improving the performance of a distributed transaction processing system when there is some regional locality of data reference are presented. A distributed computer system is maintained at each region, and a central computer system with a replication of all databases at the distributed sites is introduced. It provides the advantage of distributed systems principally for local transactions, and has the advantage of centralized systems for transactions accessing nonlocal data. Specialized protocols keep the copies at the distributed and centralized systems consistent without incurring the overhead and delay of generalized protocols for fully replicated databases. The advantages achievable through this system structure and the tradeoffs between protocols for concurrency and coherency control of the duplicate copies of the databases are studied. An approximate analytic model is used to estimate the system performance. It is found that the performance is sensitive to the protocol and that substantial performance improvement can be obtained as compared with distributed systems.