ppxscal/embedding_network huggingface dataset:
Performance evaluation of global reading of entire databases
Authors: C. Pu, C. H. Hong, J. M. Wha
Venue: Proceedings of the first international symposium on Databases in parallel and distributed systems (2000)

Using simulation and probabilistic analysis, we study the performance of an algorithm to read entire databases with locking concurrency control allowing multiple readers or an exclusive writer. The algorithm runs concurrently with the normal transaction processing (on-the-fly) and locks the entities in the database one by one (incremental). The analysis compares different strategies to resolve the conflicts between the global read algorithm and update. Since the algorithm is parallel in nature, its interference with normal transactions is minimized in parallel and distributed databases. A simulation study shows that one variant of the algorithm can read the entire database with very little overhead and interference with the updates.
Class management for software communities
Authors: Simon Gibbs, Eduardo Casais, Oscar Nierstrasz, X. Pintado, Dennis Tsichritzis
Venue: Communications of the ACM (1990)

Object-oriented programming may engender an approach to software development characterized by the large-scale reuse of object classes. Large-scale reuse is the use of a class not just by its original developers, but by other developers who may be from other organizations, and may use the classes over a long period of time. Our hypothesis is that the successful dissemination and reuse of classes requires a well-organized community of developers who are ready to share ideas, methods, tools and code. Furthermore, these communities should be supported by software information systems which manage and provide access to class collections. In the following sections we motivate the need for software communities and software information systems. The bulk of this article discusses various issues associated with managing the very large class collections produced and used by these communities.
A case study of DECnet applications and protocol performance
Authors: D.-M. Chiu, R. Sudama
Venue: ACM SIGMETRICS Performance Evaluation Review (1988)

This paper is a study based on measurements of network activities of a major site of Digital's world-wide corporate network. The study yields two kinds of results: (1) DECnet protocol performance information and (2) DECnet session statistics. Protocol performance is measured in terms of the various network overhead (non-data) packets in routing, transport and session layers. From these protocol performance data, we are able to review how effective various network protocol optimizations are; for example the on/off flow control scheme and the delayed acknowledgement scheme in the transport protocol. DECnet session statistics characterizes the workload in such a large network. The attributes of a session include the user who started it, the application invoked, the distance between the user and the application, the time span, the number of packets and bytes in each direction, and the various reasons if a session is not successfully established. Based on a large sample of such sessions, we generate distributions based on various attributes of sessions; for example the application mix, the visit count distribution and various packet number and size distributions.
Optimal algorithms for stable dimension permutations on Boolean cubes
Authors: C-T. Ho, L. Johnsson
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

In this paper we present algorithms optimal within a small constant factor for stable dimension permutations on Boolean cubes. A stable dimension permutation is a permutation such that element (wm-1wm-2 &hellip; w0) is relocated to the location of element (w&dgr;(m-1)w&dgr;(m-2)&hellip;w&dgr;(0) after the permutation, or i &rarr; &dgr;(i), where &dgr;(&middot;) is a permutation function on {0,1,&hellip;, m - 1}. Depending on communication capability, message size, cube size, data transfer rate, and communication start-up time, different algorithms must be chosen for a communication time optimal within a small constant factor. The bandwidth of the Boolean cube is fully explored by dividing the data set to be communicated between a pair of processors into subsets, one for each path between the pair of processors. The k-shuffle permutation, the bit-reversal permutation, and matrix transposition, are special cases of stable dimension permutations. Experimental results on the Intel iPSC are also provided.
Efficient motion planning for an L-shaped object
Authors: D. Halperin, M. Overmars
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

We present an algorithm that solves the following motion-planning problem. Given an L-shaped body L and a 2-dimensional region with n point obstacles, decide whether there is a continuous motion connecting two given positions and orientations of L during which L avoids collision with the obstacles. The algorithm requires &Ogr;(n2 log2 n) time and &Ogr;(n2) storage. The algorithm is a variant of the cell-decomposition technique of the configuration space ([SS, LS]) but it employs a new and efficient technique for obtaining a compact representation of the free space, which results in a saving of an order of magnitude. The approach used in our algorithm seems applicable to motion-planning of certain robotic arms whose spaces of free placements have a structure similar to that of the L-shaped body.
Pipelined data parallel algorithms&mdash;concept and modeling
Authors: C.-T. King, W.-H. Chou, L. M. Ni
Venue: Proceedings of the 2nd international conference on Supercomputing (1988)

A new style of efficient parallel algorithms on distributed-memory multiprocessors is introduced, which exploits parallelism through pipelined parallel computation, or large-grain pipelining. By using macro-pipelining between nodes in the system, large-grain pipelining regulates the flows of data in the multiprocessor so that the degree of overlapping can be maximized and the effect of communication overhead can be minimized. To model pipelined parallel computations, an analytic model is presented, which takes into account both underlying architecture and algorithm behavior. The resultant model is accurate enough to not only predict the performance of a given algorithm, but also assist in algorithm designs for determining optimal design parameters such as the granularity. Results from experiments performed on a 64-node NCUBE multiprocessor match closely to the predicted performance. A systematic procedure for designing pipelined data parallel algorithms from nested loop programs is described. The impact of the second generation distributed-memory multiprocessors on the pipelined parallel computations is also discussed.
Multivariate inferences for regenerative simulations to a specified precision level
Authors: D.-F. R. Chen
Venue: Proceedings of the 21st conference on Winter simulation (1989)

When making an inference from a simulation output, the problem we usually encounter is the autocorrelation among observations. In this paper we proposed a technique using regenerative methods to overcome this problem and establish simultaneous confidence intervals for some correlated variables to a prespecified relative precision level. Five simulation models are used to test the performance of this technique and the coverage rate is the criterion. From the empirical results, the performance of this technique is quite satisfactory.
Soar/PSM-E: investigating match parallelism in a learning production sytsem
Authors: Milind Tambe, Dirk Kalp, Anoop Gupta, Charles Forgy, Brian Milnes, Allen Newell
Venue: ACM SIGPLAN Notices (1988)

Soar is an attempt to realize a set of hypotheses on the nature of general intelligence within a single system. Soar uses a production system (rule based system) to encode its knowledge base. Its learning mechanism, chunking, adds productions continuously to the production system. The process of searching for relevant knowledge, matching, is known to be a performance bottleneck in production systems. PSM-E is a C-based implementation of the OPS5 production system on the Encore Multimax that has achieved significant speedups in matching. In this paper we describe our implementation, Soar/PSM-E, of Soar on the Encore Multimax that is built on top of PSM-E. We first describe the extensions and modifications required to PSM-E in order to support Soar, especially the capability of adding productions at run time as required by chunking. We present the speedups obtained on Soar/PSM-E and discuss some effects of chunking on parallelism. We also analyze the performance of the system and identify the bottlenecks limiting parallelism. Finally, we discuss the work in progress to deal with some of them.
A Master of Software Engineering Curriculum: Recommendations from the Software Engineering Institute
Authors: Gary A. Ford, Norman E. Gibbs
Venue: Computer (1989)

The authors present a structure of the software engineering discipline as a first step toward identifying its content and boundaries. They recommend a core Master's-level curriculum in software engineering. They discuss the future of software engineering education.
The use of business graphics
Authors: Alan R. Dennis
Venue: ACM SIGMIS Database (1988)

Business graphics are any form of graphics used by individual knowledge workers to support their activities. The classification system presented in this paper can be used to identify graphics needs and classify graphic system features. The classification system has six dimensions: form, media, quality, speed, ease of learninglease of use, and flexibility. In a study at Queen's University, most of the business graphics produced with micro-computers were text charts used to support oral presentations. Most end users preferred easy-to-use microcomputer-based tools to more flexible mainframe tools. Surprisingly, users with little prior computer experience were as likely to use computer generated computer graphics (and use the microcomputer tools themselves to create business graphics), as their more experienced counterparts. This pattern differs sharply from that on the university's central mainframe, where experienced users prepare mostly graphs.
Automata-driven indexing of Prolog clauses
Authors: R. Ramesh, I. V. Ramakrishnan, D. S. Warren
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

Indexing Prolog clauses is an important optimization step that reduces the number of clauses on which unification will be performed and can avoid the pushing of a choice point. It is quite desirable to increase the number of functors used in indexing as this can considerably reduce the size of the filtered set. However this can cause an enormous increase in running time if indexing is done naively. This paper describes a new technique for indexing that utilizes all the functors in a clause-head. More importantly, in spite of using all the functors, this technique is still able to quickly select relevant clause-heads at run time. This is made possible primarily by a finite-state automaton that guides the indexing process. The automaton is constructed at compile time by preprocessing all the clause-heads.
A type system for Smalltalk
Authors: Justin O. Graver, Ralph E. Johnson
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

This paper describes a type system for Smalltalk that is type-safe, that allows most Smalltalk programs to be type-checked, and that can be used as the basis of an optimizing compiler.
A microcoded real-time executive for numeric support nodes distributed within embedded networks
Authors: J. O. Bondi
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

The mix of nodes within heterogeneous embedded networks typically includes some highly specialized, numerically oriented nodes particularly adept at efficient manipulation of regularly structured, multi-element array operands. Such &ldquo;Array Processing&rdquo; (AP) nodes usually serve other more general-purpose (GP) nodes. Local node-level control of each AP is maintained by a microcoded AP-resident executive program (APX). The APX is carefully microcoded and tuned to minimize overhead incurred by the computation-or-throughput-intensive tasks using or sharing AP resources.
Storing a tree structure by using decimal notation
Authors: J. I. Aoe
Venue: ACM SIGIR Forum (1989)

A decimal notation satisfies many simple mathematical properties, and it is a useful tool in the analysis of trees. A practical method is presented, that compresses the decimal codes while maintaining the fast determination of relations(e.g., ancestor, descendant, brother, etc.). A special node, called a kernel node, including many common subcodes of the other codes, is defined, and a compact data structure is presented using the kernel nodes. Let n(m) be the number of the total(kernel) nodes. It is theoretically proved that encoding a decimal code is a constant time, that the worst-case time complexity of compressing the decimal codes is O(n+ m2), and that the size of the data structure is proportional to m. From the experimental results of some hierarchical semantic primitives for natural language processing, it is shown that the ratio m/n becomes an extremely small value, ranging from 0.047 to 0.13.
Control store implementation of a high performance VLSI CISC
Authors: J. H. Chang, H. H. Chao, K. Lewis, M. Holland
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

The implementation of the &mgr;-sequencer and the large loadable control store of a high performance CMOS 370 system [1] is described. The control store consists of two parts, a small on-chip control store and a main control store. A small on-chip control store keeps the first two control words of each &mgr;-sequence. A large main control store contains the remaining control words of each &mgr;-sequence. The small control store is implemented so that there is no need to include an extra pipeline stage to start an instruction execution in order to achieve a short cycle time. With a short cycle time, the access of the large control store takes at least two cycles to complete. In order to get one control word every cycle, the access to the control store is pipelined. A static &mgr;-branch prediction scheme is used to generate the next &mgr;-address ahead of the determination of a &mgr;-branch. With this scheme, an effectively one-cycle access from a large loadable control store can be achieved without affecting the machine cycle time.
A survey of methods for eliciting the knowledge of experts
Authors: Robert R. Hoffman
Venue: Issue 108 (April 1989) (1989)

A variety of methods have been used by expert system developers to elicit experts' knowledge and reasoning strategies. Additionally, a number of methods have been used by experimental psychologists to explore hypotheses about the nature of expertise. Methods can be placed into three broad categories: (1) Analyses of the tasks that experts perform, (2) Interview techniques, and (3) Special tasks. A comparison of knowledge elicitation methods yields recommendations about how expert system developers can deal with the "knowledge acquisition bottleneck."
Variable-depth trie index optimization: theory and experimental results
Authors: R. Ramesh, A. J. G. Babu, J. Peter Kincaid
Venue: ACM Transactions on Database Systems (TODS) (1989)

We develop an efficient approach to Trie index optimization. A Trie is a data structure used to index a file having a set of attributes as record identifiers. In the proposed methodology, a file is horizontally partitioned into subsets of records using a Trie index whose depth of indexing is allowed to vary. The retrieval of a record from the file proceeds by &ldquo;stepping through&rdquo; the index to identify a subset of records in the file in which a binary search is performed. This paper develops a taxonomy of optimization problems underlying variable-depth Trie index construction. All these problems are solvable in polynomial time, and their characteristics are studied. Exact algorithms and heuristics for their solution are presented. The algorithms are employed in CRES-an expert system for editing written narrative material, developed for the Department of the Navy. CRES uses several large-to-very-large dictionary files for which Trie indexes are constructed using these algorithms. Computational experience with CRES shows that search and retrieval using variable-depth Trie indexes can be as much as six times faster than pure binary search. The space requirements of the Tries are reasonable. The results show that the variable-depth Tries constructed according to the proposed algorithms are viable and efficient for indexing large-to-very-large files by attributes in practical applications.
An Evaluation of Expert Systems for Software Engineering Management
Authors: Connie L. Ramsey, Victor R. Basili
Venue: IEEE Transactions on Software Engineering (1989)

The development of four separate, prototype expert systems to aid in software engineering management is described. Given the values for certain metrics, these systems provide interpretations which explain any abnormal patterns of these values during the development of a software project. The four expert systems which solve the same problem, were built using two different approaches to knowledge acquisition, a bottom-up approach and a top-down approach and two different expert system methods, rule-based deduction and frame-based abduction. In a comparison to see which methods might better suit the needs of this field, it was found that the bottom-up approach led to better results that did the top-down approach, and the rule-based deduction systems using simple rules provided more complete and correct solutions than did the frame-based abduction systems.
An overview of the X toolkit
Authors: Joel McCormack, Paul Asente
Venue: Proceedings of the 1st annual ACM SIGGRAPH symposium on User Interface Software (1988)

The X11 Window System defines a network protocol [6] for communication between a graphics server and an application. The X library [3] provides a procedural interface to the protocol. The X toolkit [4] is an object-oriented construction kit built on top of the X library. The toolkit is used to write user interface components (&ldquo;widgets&rdquo;), to organize a set of widget instances into a complete user interface, and to link a user interface with the functionality provided by an application. This paper describes the capabilities and structure of the X toolkit from three viewpoints: application developer, widget writer, and application user. We discuss the toolkit's mechanisms to address inefficiencies caused by the separation of application and server, and by the extensive user configurability of toolkit-based applications. We point out some drawbacks to using the toolkit, and briefly describe the tools being developed to overcome these problems.
Teaching recursion as a problem-solving tool using standard ML
Authors: Peter B. Henderson, Francisco J. Romero
Venue: ACM SIGCSE Bulletin (1989)

Standard ML is a state of the art functional programming language, with features that make it excellent for teaching recursion and problem solving at the introductory level. Among the many pedagogically interesting characteristics of ML are its simple and uniform syntax, its type polymorphism and type inferencing system, and datatype declaration facilities. With little formal ML instruction, after several weeks first year students were able to use recursively defined data structures and to define fairly powerful recursive functions in ML. Standard ML is highly recommended as a tool for teaching recursive problem solving in the context of a course on the foundations of computer science.
Integrating causal reasoning at different levels of abstraction
Authors: Eva Hudlicka, Kevin Corker
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

In this paper we describe a problem-solving system which uses a multi-level causal model of its domain. The system functions in the role of a pilot's assistant in the domain of commercial air transport emergencies. The model represents causal relationships among the aircraft subsystems, the effectors (engines, control surfaces), the forces that act on an aircraft in flight (thrust, lift), and the aircraft's flight profile (speed, altitude, etc.). The causal relationships are represented at three levels of abstraction: Boolean, qualitative, and quantitative, and reasoning about causes and effects can take place at each of these levels. Since processing at each level has different characteristics with respect to speed, the type of data required, and the specificity of the results, the problem-solving system can adapt to a wide variety of situations. The system is currently being implemented in the KEE&trade; development environment on a Symbolics Lisp machine.
Reliable, reusable Ada components for constructing large, distributed multi-task networks: networks architecture services (NAS)
Authors: W. Royce
Venue: Proceedings of the conference on Tri-Ada '89: Ada technology in context: application, development, and deployment (1989)

This paper will introduce the key concepts of TRW's Reusable Message Based Design Software (Network Architecture Services- NAS) which has proven to be key to the CCPDS-R project's progress to date. The NAS software and supporting tools have provided the CCPDS-R Project team with reliable, powerful building blocks that have been integrated into extensive demonstrations to validate the critical design approaches. The CCPDS-R PDR Demonstration consisted of 130 Ada tasks interconnected via 450 different task to task interfaces, executing in a network of 3 VAX nodes. The extensive reuse of NAS software building blocks and Ada generics resulted in the translation of 120,000 Ada Source lines into over 2 million lines of executable machine language instructions. The NAS software (about 20,000 Ada source lines) was conceived in a TRW Independent Research and Development project in 1985, and has since been refined and evolved into a truly reusable state. Although NAS reuse is limited currently to Digital Equipment Corporation VAX VMS networks, efforts are underway to provide heterogeneous NAS capabilities. The advantages of NAS usage are twofold: Value added operational software through reuse of mission independent, performance tunable components which support open architectures, and Overall project productivity enhancement as a result of NAS support for rapid prototyping, runtime instrumentation toolsuite, and encapsulation of the difficult capabilities required in any distributed real-time system into a standard set of building blocks with simple applications interfaces. This isolation of the &ldquo;hard parts&rdquo; into an easily used standard software chipset, results in a large net reduction in applications software complexity, less reliance on scarce real-time programming experts, and a substantial reduction in overall project risk. This paper describes the message based design techniques which drove us to the development of NAS, the capabilities and components inherent in the NAS product, and the CCPDS-R experience in using NAS in a stringent real time command and control environment.