ppxscal/embedding_network huggingface dataset:
Quadtree-Structured Linear Prediction Models for Image Sequence Processing
Authors: P. Strobach
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

A summary is presented of a study on two-dimensional linear prediction models for image sequence processing and its application to change detection and scene coding. The study focused on two-dimensional joint process modeling of interframe relationships, the derivation of computationally efficient matching algorithms, and the implementation of a block-adaptive interframe predictor for use in interframe predictive coding and change detection. In the approach presented, the spatial nonstationarity is handled by an underlying quadtree segmentation structure. A maximum-likelihood criterion and a simpler minimum-variance criterion are discussed as detection and segmentation rules. The results of this research indicate that a constrained joint process model involving only a single gain parameter and a shift parameter is the best tradeoff between performance and computational complexity.
Temporal logic programming
Authors: Martín Abadi, Zohar Manna
Venue: Journal of Symbolic Computation (1989)

Temporal logic, often used as a specification language for programs, can serve directly as a programming language. We propose a specific programming language TEMPLOG, which extends the classical PROLOG-like languages to include temporal operators. PROLOG progams are collections of classical Horn clauses and they are efficiently interpreted by SLD-resolution. Similarly, TEMPLOG programs are collections of temporal Horn clauses and we interpret them with temporal SLD-resolution, a restricted form of a general temporal resolution method.
Lessons learned from modeling the dynamics of software development
Authors: Tarek K. Abdel-Hamid, Stuart E. Madnick
Venue: Communications of the ACM (1989)

Software systems development has been plagued by cost overruns, late deliveries, poor reliability, and user dissatisfaction. This article presents a paradigm for the study of software project management that is grounded in the feedback systems principles of system dynamics.
Introducing symbolic problem solving techniques in the dependence testing phases of a vectorizer
Authors: A. Lichnewsky, F. Thomasset
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

The purpose of a vectorizer is to perform program restructuring in order to exhibit the most efficiently exploitable forms of vector loops. This is guided by a suitable form of semantic analysis, Dependence Testing, which must be precise in order to fully exploit the architecture. Most studies reduce this phase to the application of a series of explicitly computable arithmetic criteria. In many cases, this will fail if the criteria cannot be computed numerically, and contain symbols which cannot be evaluated. This also makes the use of other information pertaining to these symbols difficult. It is shown here that it is possible to extract symbolic equations from some of the classical criteria, merge them with other symbolic knowledge about the program, and use the global system to decide the non-existence of a dependence. In the context of the VATIL vectorizer [17, 16], it is also shown possible to control the computation cost, and obtain a good overall efficiency.
Estimating the Speedup in Parallel Parsing
Authors: Dilip Sarkar, Narsingh Deo
Venue: IEEE Transactions on Software Engineering (1990)

A method for estimating the speedup for asynchronous bottom-up parallel parsing is presented. Two models for bottom-up parallel parsing are proposed, and the speedup for each of the two models is estimated. The speedup obtained for model A is a very close to the simulation result already available in literature; however, the model is restrictive because it can only communicate with its immediate left and right neighbors. This increases the processor coordination and interprocessor communication times. Model B, while showing a greater speedup time, is expensive to construct when the number of processors is large.
A framework to support an object-oriented view of existing engineering databases
Authors: Rafiul Ahad
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

This paper presents a framework for an Object Management System (OMS) to support an object-oriented view of an existing engineering database. OMS is intended to run on a workstation to access the engineering database on another machine (host). OMS has three components: a Data Model (DM) to define the objects and the relationships among the objects that exist in the host database, a Transformation Model (TM) to define the modeling concepts that are not directly supported in the DM, and a Mapping Facility/Optimizer (MF/O) to map the relationships to data stored in the host, and to build a host-executable program for each query the user issues. Mapping is done by host-executable procedures that encode the knowledge about the access to host-resident data. MF/O optimizes access to the host's database.
Mass storage support for supercomputing
Authors: R. F. Bedoll
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

Mass Storage support for supercomputing at Boeing Computer Services is satisfied by a locally developed storage system known as FMS, the File Management System. The product of a joint development project between CDC and Boeing, it runs on a dedicated back-end system and communicates with multiple processor types through several different local area networks. FMS follows the proposed IEEE mass storage reference model. This paper discusses many of the problems and benefits which arise when implementing a file system which addresses supercomputing as a component of a large data center.
To correct communicating finite state machines
Authors: H. Mountassir
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

A number of methods have been proposed to validate the communication between processes which exchange messages through bounded FIFO channels. However design criteria and rules are developed to construct correct protocols. In this paper, our objective is to propose a new correcting method for a pair of communicating finite state machines and we ensure that the communication is perfect and progresses indefinitely i.e deadlock-free, liveness, bounded, and without noexecutable transitions, unspecified receptions. The time complexity is bounded by O(nm) where n is the number of states and m is the number of transitions of a given machine. The first method is defined by adding receiving transitions and in the second we complete our results by adding sending transitions , then we obtain symmetric and isomorphic machines with unbounded communication.
Locating functional errors in logic circuits
Authors: K. A. Tamura
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

In the verification phase of the design of logic circuits using the top-down approach, it is necessary not only to detect but also to locate the source of any inconsistencies that may exist between the functional-level description and its gate-level implementation. In this paper we present a method that determines the areas, within the gate-level circuit, that contain the functional errors. The indicated areas are shown to have sufficient resolution to allow the designer to quickly find the cause of the inconsistency and, therefore, reduce the time required for debugging.
Indefinite integration with validation
Authors: George Corliss, Gary Krenz
Venue: ACM Transactions on Mathematical Software (TOMS) (1989)

We present an overview of two approaches to validated one-dimensional indefinite integration. The first approach is to find an inclusion of the integrand, then integrate this inclusion to obtain an inclusion of the indefinite integral. Inclusions for the integrand may be obtained from Taylor polynomials, Tschebyscheff polynomials, or other approximating forms which have a known error term. The second approach finds an inclusion of the indefinite integral directly as a linear combination of function evaluations plus an interval-valued error term. This requires a self-validating form of a quadrature formula such as Gaussian quadrature. In either approach, composite formulae improve the accuracy of the inclusion. The result of the validated indefinite integration is an algorithm which may be represented as a character string, a subroutine in a high-level programming language such as Pascal-SC or Fortran, or as a collection of data. An example is given showing the application of validated indefinite integration in constructing a validated inclusion of the error function, erf(x).
The University of Washington illustrating compiler
Authors: Robert R. Henry, Kenneth M. Whaley, Bruce Forstall
Venue: ACM SIGPLAN Notices (1990)

The University of Washington illustrating compiler (UWPI) automatically illustrates the data structures used in simple programs written in a subset of Pascal2. A UWPI user submits a program to UWPI, and can then watch a graphical display show time varying illustrations of the data structures and program source code. UWPI uses the information latent in the program to determine how to illustrate the program. UWPI infers the abstract data types directly from the declarations and operations used in the source program, and then lays out the illustration in a natural way by instantiating well-known layouts for the abstracts types. UWPI solves program illustration using compile-time pattern matching and type inferencing to link anticipated execution events to display events, rather than relying on user assistance or specialized programming techniques. UWPI has been used to automatically illustrate didactic sorting and searching examples, and can be used to help teach basic data structures, or to help when debugging programs.
Parsing with flexibility, dynamic strategies, and idioms in mind
Authors: Oliviero Stock
Venue: Computational Linguistics (1989)

One desirable aspect of a syntactic parser is being meaningful (i.e., contributing to incremental interpretation) during the process of parsing and not only at the end of it. This becomes even more important when dealing with flexible word order languages, where the number of alternatives in parsing may grow dangerously. One such parser is WEDNESDAY 2. It is a lexicon-based parser, relying on the chart mechanism combined with a particular kind of unification, guided by the so-called Principle of the Good Clerk. The paradigm is a multiprocessing one and the experimentation with dynamic syntactic strategies (what heuristics may sensibly guide the process, for instance within a particular sublanguage) is a relevant task here. An interactive integrated environment built around the parser is described. Flexible idiom processing is one of the best features of WEDNESDAY 2. Idioms are treated as decomposable parts of speech and the treatment of idiom recognition does not differ from the "literal" process until a threshold of activation of a flexible pattern is crossed. At that point a new, idiomatic process is added.
Completeness of rewrite rules and rewrite strategies for FP
Authors: Joseph Y. Halpern, John H. Williams, Edward L. Wimmers
Venue: Journal of the ACM (JACM) (1990)

This paper treats languages whose operational semantics is given by a set of rewrite rules. For such languages, it is important to be able to determine that there are enough rules to be able to compute the correct meaning of all expressions, but not so many that the system of rules is inconsistent. A formal framework is developed in which to give a precise treatment of these completeness and soundness issues, which are then investigated in the context of an extended version of the functional programming language FP. The rewrite rules of FP are shown to be sound and complete with respect to three different notions of completeness. The latter half of the paper considers rewrite strategies. In order to implement a language based on rewrite rules, it does not suffice to know that there are &ldquo;enough&rdquo; rules in the language; a good strategy for determining the order in which to apply them is also needed. But what is &ldquo;good&rdquo;? Corresponding to each notion of completeness, there is a notion of a good rewrite strategy. These notions of goodness are examined and characterized, and examples of a number of natural good strategies are given. Although these results are presented in the context of FP, the techniques (some of which are nontrivial extensions of techniques first used in the context of &lgr;-calculus) should apply well beyond the realm of FP rewriting systems.
Static Analysis of Real-Time Distributed Systems
Authors: Leo Yuhsiang Liu, R. K. Shyamasundar
Venue: IEEE Transactions on Software Engineering (1990)

A static analysis for reasoning about the temporal behaviors of programs in real-time distributed programming languages is proposed. The analysis is based on the action set semantics using the pure maximal parallelism model. It is shown how to specify and verify various timing properties of real-time programs. The approach provides only an approximate timing behavior, because the state information is ignored. However, many interesting properties such as parallel actions, deadlocks, livelocks, terminations, temporal errors, and failures, can be identified. Furthermore, the approach is compositional and thus makes it possible to reason about the timing properties incrementally. The method not only leads to efficient algorithms for the static analysis of CSP programs but also applies to many other languages.
A Three-Module Strategy for Edge Detection
Authors: Vinciane Lacroix
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

The first module is a parallel process computing local edge strength and direction, while the last module is sequential process following edges. The originality of the overall method resides in the intermediate module, which is seen as a generalization of the nonmaximum-deletion algorithm. The role of this module is twofold: It enables one to postpone some deletion to the last module where contextual information is available, and it transmits the local edge direction in order to guide the contour following. A postprocessing method called learning edges is proposed as a refinement of the method. The binary edge images extracted from various gray-level images illustrate the power of the strategy.
Relational specifications of infinite query answers
Authors: Jan Chomicki, Tomasz Imieliński
Venue: Proceedings of the 1989 ACM SIGMOD international conference on Management of data (1989)

We investigate here functional deductive databases: an extension of DATALOG capable of representing infinite phenomena. Rules in functional deductive databases are Horn and predicates can have arbitrary unary and limited k-ary function symbols in one fixed position. This class is known to be decidable. However, least fixpoints of functional rules may be infinite. We present here a method to finitely represent infinite least fixpoints and infinite query answers as relational specifications. Relational specifications consist of a finite set of tuples and of a finitely specified congruence relation. Our method is applicable to every domain-independent set of functional rules.
Using video in the BNR usability lab
Authors: S. Kennedy
Venue: ACM SIGCHI Bulletin (1989)

This paper describes the goals of the BNR Usability Lab and explains how we have achieved our goals by developing the "Co-Discovery Learning" testing methodology and designing "U-Test", a special interface for usability testing with video.
Information retrieval and software reuse
Authors: W. B. Frakes
Venue: ACM SIGIR Forum (1989)

Software reuse is widely believed to be the most promising technology for improving software quality and productivity. There are many technical and non-technical problems to be solved, however, before widespread reuse of software lifecycle objects becomes a reality. One class of problem concerns the classification, storage, and retrieval of reusable components. Panel members will discuss these problems and some approaches to solving them.
&ldquo;Cactus Systems&rdquo;: a computer science practicum that is more than a capstone
Authors: Charles P. Howerton
Venue: ACM SIGCSE Bulletin (1988)

This paper describes a project-oriented Computer Science or Computer Information Systems Practicum course. This particular course differs in several ways from other similar courses. First, it is taught outside of the normal academic year. Second, a real attempt is made to simulate the environment in which a computing professional would be expected to work. Third, all of the projects are taken from the real world and are sponsored by individuals who actually want the work done. Fourth, it has components designed to teach the students how to make informal and formal public speeches on subjects with which they are familiar. Finally, it has components designed to help the students look for jobs after graduation. This course has worked well at a major engineering school and at a small regional liberal arts school.
Partial computation as a practical aid in the compiler construction course
Authors: Frank G. Pagan
Venue: ACM SIGCSE Bulletin (1989)

A brief account of the concept of partial computation is given in the context of the Pascal language. The manual conversion of programs into generating extensions is explained using examples of gradually increasing complexity. This culminates in a readily applicable but too-little known technique of converting interpreters into compilers without dealing directly with machine language. Students taking courses in language processing should be taught this technique and perhaps also the general principles underlying it. A simple example of the application of the technique is presented.
Threads and input/output in the synthesis kernal
Authors: H. Massalin, C. Pu
Venue: ACM SIGOPS Operating Systems Review (1989)

The Synthesis operating system kernel combines several techniques to provide high performance, including kernel code synthesis, fine-grain scheduling, and optimistic synchronization. Kernel code synthesis reduces the execution path for frequently used kernel calls. Optimistic synchronization increases concurrency within the kernel. Their combination results in significant performance improvement over traditional operating system implementations. Using hardware and software emulating a SUN 3/160 running SUNOS, Synthesis achieves several times to several dozen times speedup for UNIX kernel calls and context switch times of 21 microseconds or faster.
An accurate and efficient performance analysis technique for multiprocessor snooping cache-consistency protocols
Authors: M. K. Vernon, E. D. Lazowska, J. Zahorjan
Venue: ACM SIGARCH Computer Architecture News (1988)

A number of dynamic cache consistency protocols have been developed for multiprocessors having a shared bus interconnect between processors and shared memory. The relative performance of these protocols has been studied extensively using simulation and detailed analytical models based on Markov chain techniques. Both of these approaches use relatively detailed models, which capture cache and bus interference rather precisely, but which are highly expensive to evaluate. In this paper, we investigate the use of a more abstract and significantly more efficient analytical model for evaluating the relative performance of cache consistency protocols. The model includes bus interference, cache interference, and main memory interference, but represents the interactions between the caches by steady-state mean collision rates which are computed by iterative solution of the model equations. We show that the speedup estimates obtained from the mean-value model are highly accurate. The results agree with the speedup estimates of the detailed analytical models to within 3%, over all modifications studied and over a wide range of parameter values. This result is surprising, given that the distinctions among the protocols are quite subtle. The validation experiments include sets of reasonable values of the workload parameters, as well as sets of unrealistic values for which one might expect the mean-value equations to break down. The conclusion we can draw is that this modeling technique shows promise for evaluating architectural tradeoffs at a much more detailed level than was previously thought possible. We also discuss the relationship between results of the analytical models and the results of independent evaluations of the protocols using simulation.
Simulation of simplicity: a technique to cope with degenerate cases in geometric algorithms
Authors: Herbert Edelsbrunner, Ernst Peter Mücke
Venue: ACM Transactions on Graphics (TOG) (1990)

This paper describes a general-purpose programming technique, called Simulation of Simplicity, that can be used to cope with degenerate input data for geometric algorithms. It relieves the programmer from the task of providing a consistent treatment for every single special case that can occur. The programs that use the technique tend to be considerably smaller and more robust than those that do not use it. We believe that this technique will become a standard tool in writing geometric software.
Parasight: a high-level debugger/profiler architecture for shared-memory multiprocessor
Authors: Z. Aral, Ilya Gertner
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

Existing debuggers and profilers are inadequate for debugging and profiling parallel programs. They are awkward in their handling of multiple threads of control and highly intrusive in their monitoring of program behavior. ParasightTM is an architecture that is geared towards non-intrusive high-level debugging and profiling. Parasight controls and observes the execution of parallel programs in terms of the set of abstractions that are being employed by the programmer. Different sets of abstractions can be implemented and applied to the same target program to extract different kinds of information. These abstractions are implemented as separate programs that are linked dynamically to the target program by Parasight. This paper describes our experience in implementing and using Parasight on the Encore Multimax,TM a shared-memory multiprocessor running UNIXTM. It has been used successfully in debugging and monitoring the performance of a computer architecture simulator, a complex parallel program.
Modelling and performance evaluation of multiprocessors, organizations with multi-memory units
Authors: M. Naderi
Venue: ACM SIGARCH Computer Architecture News (1988)

In a multiprocessors configuration, a memory conflict occurs whenever two or more processors or I/O, s attempt to access the same memory unit simultaneously. The overall effect of these conflicts are lose of the system efficiency. A multiprocessor activity during execution of a program has been considered as a stochostic process which moves through a countable set of states. The process decides where to go next by a random mechanism which depends only on the current state and not on the previous history or even on the time. This kind of process is called Markov process. The transition from any state is possible only to the neighbouring states due to these conditions that the arrivale of request rate from processors and the memory communication rate follow a poisson distribution. Under these assumations a multi-server waiting line model has been developed for a multi-processors organisation. The basic motivation for this investigation will be the search to find a set of system parameters to measure the multiprocessors. performance with multi-memory nuits.The Makrovian waiting line model has been emplayed and obtained a general solution to estimate the effect of memory conflict on the average number of waiting units in the system, idle and busy periods for memory unit, system efficiency, the stretching factor of program on bases of "First Com, First Served" descipline.The simulation programs written by Basic to implement the developed waiting line model are general enough so that a system configuration of any size can be studied.