ppxscal/embedding_network huggingface dataset:
Ada Program Partitioning Language: A Notion for Distributing Ada Programs
Authors: Rakesh Jha, Dennis T. Cornhill, J. Michael Kamrad,  II
Venue: IEEE Transactions on Software Engineering (1989)

Ada Program Partitioning Language (APPL) has been designed as part of Honeywell's Distributed Ada project. The goal of the project is to develop an approach for reducing the complexity of building distributed applications in Ada. In the proposed approach, an application is written as a single Ada program using the full capabilities of the Ada language. It is not necessary to factor the underlying hardware configuration into the program design. Once the program has been completed and tested in the host development environment, it is partitioned into fragments and mapped onto the distributed hardware. The partitioning and mapping are expressed in APPL and do not require changes to the Ada source. The main thrusts of the project include the design of APPL and the development of language translation tools and the run-time system to support Ada and APPL for a distributed target. The authors present an overview of APPL, the goals considered in the design, and issues that impact its implementation.
Measurement and Analysis of Workload Effects on Fault Latency in Real-Time Systems
Authors: Michael H. Woodbury, Kang G. Shin
Venue: IEEE Transactions on Software Engineering (1990)

The authors demonstrate the need to address fault latency in highly reliable real-time control computer systems. It is noted that the effectiveness of all known recovery mechanisms is greatly reduced in the presence of multiple latent faults. The presence of multiple latent faults increases the possibility of multiple errors, which could result in coverage failure. The authors present experimental evidence indicating that the duration of fault latency is dependent on workload. A synthetic work generator is used to vary the workload, and a hardware fault injector is applied to inject transient faults of varying durations. This method makes it possible to derive the distribution of fault latency duration. Experimental results obtained from the fault-tolerant multiprocessor at the NASA Airlab are presented and discussed.
Designers' models of the human-computer interface
Authors: Douglas J. Gillan, Sarah D. Breedin
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

An experiment investigated the organization of declarative knowledge about the human computer interface (HCI). Two groups of experts in user interface design (human factors experts and software experts), and a control group sorted HCI concepts into categories. The data were transformed into measures of dissimilarity and analyzed using (1) hierarchical cluster analysis and (2) Pathfinder, a program that generates network representations of the data. Both expert groups had greater numbers of clusters, more elaborate clusters, and better organized networks than did the controls. The two expert groups differed with respect to the clustering of concepts related to display coding and software. The Pathfinder networks for the two expert groups differed in organization, with human factors experts' networks consisting of highly interrelated subnetworks and software experts networks consisting of central nodes and fewer, less interconnected subnetworks. The networks also differed in the number of concepts linked with such concepts as graphics, natural language, function keys, and speech recognition. The discussion focuses on (1) specific differences in cognitive models between HCI experts and novices and between different types of experts, and (2) the role of cognitive models in HCI design and in communications within a multidisciplinary design team.
Generating Octrees from Object Silhouettes in Orthographic Views
Authors: Narendra Ahuja, Jack E. Veenstra
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

An algorithm to construct the octree representation of a three-dimensional object from silhouette images of the object is described. The images must be obtained from thirteen viewing directions corresponding to the three face views, six edge views, and four corner views of an upright cube. These views where chosen because they provide a simple relationship between pixels in the image and the octant labels in the octree, thus replacing the computation of detecting intersections between the octree space and the objects by a table lookup operation. The average ratio of the object volume to the octree volume is found to be greater than 90%. The sequential use made of the chosen viewing directions results in a coarse-to-fine acquisition of occupancy information. The number and order of the viewpoints used provides a mechanism for trading accuracy of the representation against the computational effort needed to obtain the representation.
Implementing a distributed combat simulation on the Time Warp operating system
Authors: F. Wieland, L. Hawley, A. Feinberg
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

Utilizing the Time Warp Operating System, the CTLS project at JPL has produced a distributed combat simulation called STB-87 and measured its performance on the JPL Mark III Hypercube. By applying the spiral model of software development, the CTLS project will produce a series of software test beds, to culminate in the completion of a working prototype theater level simulation three to five years hence. STB-87, the first software test bed, is a ground-based combat simulation decomposed into objects which communicate via time-stamped messages. The use of incremental object-based design, coding, and testing has been helpful when developing a parallel simulation. The performance measurements show that, with the appropriate choice of object granularity, STB-87 is able to achieve a speedup factor of 12 running on a 32-node Mark III Hypercube.
Linearizability: a correctness condition for concurrent objects
Authors: Maurice P. Herlihy, Jeannette M. Wing
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1990)

A concurrent object is a data object shared by concurrent processes. Linearizability is a correctness condition for concurrent objects that exploits the semantics of abstract data types. It permits a high degree of concurrency, yet it permits programmers to specify and reason about concurrent objects using known techniques from the sequential domain. Linearizability provides the illusion that each operation applied by concurrent processes takes effect instantaneously at some point between its invocation and its response, implying that the meaning of a concurrent object's operations can be given by pre- and post-conditions. This paper defines linearizability, compares it to other correctness conditions, presents and demonstrates a method for proving the correctness of implementations, and shows how to reason about concurrent objects, given they are linearizable.
Task-oriented representation of asynchronous user interfaces
Authors: A. C. Siochi, H. R. Hartson
Venue: ACM SIGCHI Bulletin (1989)

A simple, task-oriented notation for describing user actions in asynchronous user interfaces is introduced. This User Action Notation (UAN) allows the easy association of actions with feedback and system state changes as part of a set of asynchronous interface design techniques, by avoiding the verbosity and potential vagueness of prose. Use within an actual design and implementation project showed the UAN to be expressive, concise, and highly readable because of its simplicity. The task- and user-oriented techniques are naturally asynchronous and a good match for object-oriented implementation. Levels of abstraction are readily applied to allow definition of primitive tasks for sharing and reusability and to allow hiding of details for chunking. The UAN provides a critical articulation point, bridging the gap between the task viewpoint of the behavioral domain and the event-driven nature of the object-oriented implementational domain. The potential for UAN task description analysis may address some of the difficulties in developing asynchronous interfaces.
An efficient pipelined dataflow processor architecture
Authors: J. B. Dennis, G. R. Gao
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

This paper demonstrates that the principles of pipelined instruction execution can be effectively applied in dataflow computers, yielding an architecture that avoids the main sources of pipeline gaps during program execution in many conventional processor designs. The new processing element design uses an architecture called argument-fetch dataflow architecture. It has two parts: a dataflow instruction scheduling unit (DISU) and a pipelined instruction processing unit (PIPU). The PIPU is an instruction processor that uses many conventional techniques to achieve fast pipelined operation. The DISU holds the dataflow signal graph of the collection of dataflow instructions allocated to the processing element, and maintains a large pool of enabled instructions available for execution by the PIPU. The new architecture provides a basis for achieving high performance for many scientific applications. To show that the realization of an efficient dataflow processing element is feasible, a trial design and fabrication of an enable memory-a key component of the DISU-is reported.
Angiogram analysis in APL: a case study
Authors: Ian Feldberg
Venue: ACM SIGAPL APL Quote Quad (1990)

Angiograms are commonly used to diagnose the occurrence of an arterial occlusion. Dye is injected into a blood vessel, where its movement is tracked and recorded with x-rays. Currently, a physician uses these pictures to make a qualitative judgment on the state of the heart or artery. Unfortunately, these judgments are quite often incorrect. A joint project between the Johns Hopkins Hospital and the Applied Physics Laboratory has been investigating the feasibility of digitally analyzing these angiograms, in order to better understand how blood flows through the heart and what type of occlusions are truly dangerous. APL became instrumental in this project because its powerful array manipulation functions allowed us to test our algorithms very quickly. In this overview, some of APL's features are discussed and compared to their equivalents in other software packages.
A Multiresolution Hierarchical Approach to Image Segmentation Based on Intensity Extrema
Authors: L. M. Lifshitz, S. M. Pizer
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

A computer algorithm which segments gray-scale images into regions of interest (objects) has been developed. These regions can provide the basis for scene analysis (including shape-parameter calculation) or surface-based, shaded-graphics display. The algorithm creates a tree structure for image description by defining a linking relationship between pixels in successively blurred versions of the initial image. The image is described in terms of nested light and dark regions. This algorithm, successfully implemented in one, two, and three dimensions, can theoretically work with any number of dimensions. The interactive postprocessing developed technique selects regions from the descriptive tree for display in several ways: pointing to a branch of the image description tree, specifying by sliders the range of scale and/or intensity of all regions which should be displayed, and pointing (on the original image) to any pixel in the desired region. The algorithm has been applied to approximately 15 computer tomography (CT) images of the abdomen.
Generalized conjunctive types
Authors: G. Monteleone
Venue: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

The definitions of Conjunctive types and their subtype relation, as introduced by Coppo-Dezani, are extended to consider the conjunction as a partial mapping from pairs of types to types, and the subtype relation as a relation between finite sets of types and types. These extensions basically mean that only conjunctions of compatible types are allowed and that the subtype relation is more like, so to speak, the implication in propositional logic. We show that the basic properties of the typing system with conjunctive types are still true. The terms that have a type are exactly the terms that are convertible to a head normal form and it is possible to characterize the terms with normal form by means of the types that are derivable for them in the system. Furthermore, the type assignment defines the interpretation of terms in a very general class of models of the &lgr;-calculus: the models that are based on an information system, as defined by Scott.
A Rapid Prototyping Facility for Flight Research in Advanced Systems Concepts
Authors: Eugene L. Duke, Randal W. Brumbaugh, James D. Disbrow
Venue: Computer (1989)

A description is given of the rapid prototyping facility (RPF) at the Dryden Flight Research Facility of the US National Aeronautics and Space Administration. The facility, also known as the remotely augmented vehicle (RAV) facility, has been used to test control-law concepts on the F-8 DFBW (digital fly-by-wire) aircraft. It is intended as an adjunct to the usual avionics development process.
Conceptual Modeling of Coincident Failures in Multiversion Software
Authors: B. Littlewood, D. R. Miller
Venue: IEEE Transactions on Software Engineering (1989)

Work by D.E. Eckhardt and L.D. Lee (1985), shows that independently developed program versions fail dependently. The authors show that there is a precise duality between input choice and program choice in this model and consider a generalization in which different versions can be developed using diverse methodologies. The use of diverse methodologies is shown to decrease the probability of the simultaneous failure of several versions. Indeed, it is theoretically possible to obtain versions which exhibit better than independent failure behavior. The authors formalize the notion of methodological diversity by considering the sequence of decision outcomes that constitute a methodology. They show that diversity of decision implies likely diversity of behavior for the different versions developed under such forced diversity. For certain one-out-of-n systems the authors obtain an optimal method for allocating diversity between versions. For two-out-of-three systems there seem to be no simple optimality results which do not depend on constraints which cannot be verified in practice.
On Functional Testing of Array Processors
Authors: D. Sciuto, F. Lombardi
Venue: IEEE Transactions on Computers (1988)

This correspondence presents a new testing method for single instruction multiple data (SIMD) VLSI arrays. A new fault model is presented. Faults are defined at the functional level. A systematic test generation procedure is derived. Testing is performed by sequences of instructions. Two criteria are used. The first criterion establishes the external observability and controllability of the instructions. The second criterion uses instruction cardinality as a metric of instruction complexity. An example of the application of the proposed technique to an existing parallel scheme is described.
A Note on Nondeterminism in Small, Fast Parallel Computers
Authors: I. Parberry
Venue: IEEE Transactions on Computers (1989)

Nondeterministic analogues of the well-known language classes NC and SC called NNC and NSC, respectively, are investigated. NC is the class of languages that can be accepted by small, fast parallel computers; SC is the class of languages that can be recognized by a deterministic Turing machine in polynomial time and polylog tape-head reversals. Adding nondeterminism to SC leaves it in the domain of parallel computation since NSC contained in POLYLOGSPACE. That is, NSC is a subset of the class of languages computable by fast parallel computers. Adding nondeterminism to NC appears to make it much more powerful since NNC=NP. It is clear that NSC contained in NNC, and probable that NSC contained in/implied by NNC. Further evidence for this conjecture is provided by showing that NSC is precisely the class of languages recognizable in simultaneous polynomial time and polylog reversals by a nondeterministic Turing machine with a read-only input tape and a single read-write work tape; it is known that NNC is similar, but is recognizable by a Turing machine with two read-write tapes.
An Interconnection Network for Distributed Recursive Computations
Authors: Alain J. Martin, Jan L. A. van de Snepscheut
Venue: IEEE Transactions on Computers (1990)

Distributed computations may be viewed as a set of communicating processes. If such a computation is to be executed by a multiprocessor system, the processes have to be distributed over the processors, and the communications have to be distributed over a network. This leads to the questions of load balancing and message routing. The authors consider distributed recursive computations and propose a class of interconnection networks that admits a homogeneous distribution of processes and trivial routing. A subclass that admits a planar embedding of the network is identified.
Fabrik: a visual programming environment
Authors: Dan Ingalls, Scott Wallace, Yu-Ying Chow, Frank Ludolph, Ken Doyle
Venue: ACM SIGPLAN Notices (1988)

Fabrik is a visual programming environment - a kit of computational and user-interface components that can be &ldquo;wired&rdquo; together to build new components and useful applications. Fabrik diagrams utilize bidirectional dataflow connections as a shorthand for multiple paths of flow. Built on object-oriented foundations. Fabrik components can compute arbitrary objects as outputs. Music and animation can be programmed in this way and the user interface can even be extended by generating graphical structures that depend on other data. An interactive type system guards against meaningless connections. As with simple dataflow, each Fabrik component can be compiled into an object with access methods corresponding to each of the possible paths of data propagation.
An overview of PCTE and PCTE+
Authors: Gerard Boudier, Ferdinando Gallo, Regis Minot, Ian Thomas
Venue: ACM SIGSOFT Software Engineering Notes (1988)

The PCTE project has defined a Public Tool Interface on which Software Engineering Environments can be constructed. The interface definition was put into the public domain in September 1986 and several implementations on several machines now exist. The PCTE+ project was set up to define a Public Tool Interface, based on the PCTE work, that could also serve for the development of defense and other high-security applications. This paper summarises the current status of PCTE activity, presents the principal concepts of PCTE and the evolutions that are being proposed in the PCTE+ project.
Knowledge acquisition from multiple experts
Authors: W. A. Wolf
Venue: Issue 108 (April 1989) (1989)

The traditional method of knowledge acquisition when constructing a knowledge-based (expert) system is to depend primarily upon a single source, usually an expert in the domain under consideration. This approach has several advantages: no need to resolve conflicts -- factual or personal -- among several experts; easier communication; a more consistent approach to solving the problems dealt with, etc. However, certain domains require the use of more than one expert to gather sufficient knowledge to construct a meaningful system. We report on one such domain and on the techniques used for knowledge acquisition from multiple experts.
On the Imaging of Fractal Surfaces
Authors: P. Kube, A. Pentland
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

An analysis is presented of the imaging of surfaces modeled by fractal Brownian elevation functions of the sort used in computer graphics. It is shown that, if Lambertian reflectance modest surface slopes and the absence of occlusions and self shadowing are assumed, a fractal surface with Fourier power spectrum proportional to f/sup beta / produces an image with power spectrum proportional to f/sup 2- beta /; here, f is the spatial frequency and beta is related to the fractional dimension value. This allows one to use the spectral falloff of the images to predict the fractal dimension of the surface.
Bounds on the Bayes Classification Error Based on Pairwise Risk Functions
Authors: F. D. Garber, A. Djouadi
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

Upper and lower bounds on the Bayes risk for multiple, composite-hypothesis classification are obtained. Bounds on the Bayes risk for M simple classes are derived in terms of the risk functions for (M-1) classes, and so on, until the desired result depends only on the pairwise (M=2) Bayes risks. A method of computing upper and lower bounds on the pairwise Bayes risk for composite classes is developed. Algorithms for computing the upper and lower bounds for the general M-class case and for composite-hypothesis classes are presented. Numerical examples of the application of the bounding techniques to a problem involving the classification of aircraft are discussed. Results for the bounds and other performance measures are compared for the most interesting cases.
Lookup tables, recurrences and complexity
Authors: R. J. Fateman
Venue: Proceedings of the ACM-SIGSAM 1989 international symposium on Symbolic and algebraic computation (1989)

The use of lookup tables can reduce the complexity of calculation of functions defined typically by mathematical recurrence relations. Although this technique has been adopted by several algebraic manipulation systems, it has not been examined critically in the literature. While the use of tabulation or &ldquo;memoization&rdquo; seems to be a particularly simple and worthwhile technique in some areas, there are some negative consequences. Furthermore, the expansion of this technique to other areas (other than recurrences) has not been subjected to analysis. This paper examines some of the assumptions. A more detailed technical report [9] is under preparation.
Adaptive backoff synchronization techniques
Authors: A. Agarwal, M. Cherian
Venue: ACM SIGARCH Computer Architecture News (1989)

Shared-memory multiprocessors commonly use shared variables for synchronization. Our simulations of real parallel applications show that large-scale cache-coherent multiprocessors suffer significant amounts of invalidation traffic due to synchronization. Large multiprocessors that do not cache synchronization variables are often more severely impacted. If this synchronization traffic is not reduced or managed adequately, synchronization references can cause severe congestion in the network. We propose a class of adaptive back-off methods that do not use any extra hardware and can significantly reduce the memory traffic to synchronization variables. These methods use synchronization state to reduce polling of synchronization variables. Our simulations show that when the number of processors participating in a barrier synchronization is small compared to the time of arrival of the processors, reductions of 20 percent to over 95 percent in synchronization traffic can be achieved at no extra cost. In other situations adaptive backoff techniques result in a tradeoff between reduced network accesses and increased processor idle time.