ppxscal/embedding_network huggingface dataset:
Protected kernels and Ada 9X real-time facilities
Authors: D. E. Wrege
Venue: ACM SIGAda Ada Letters (1992)

Many of the Ada 9X mappings will have a dramatic impact on current implementations of Ada run-time executives. This impact is particularly severe for the case of run-time systems that are implemented with protected kernels, often required in real-time military imbedded systems. Further, we believe that run-time systems that provide these new 9X facilities will be required to use techniques that are less efficient than current run-time systems at providing Ada 83 tasking services. Consequently, existing Ada systems tha t meet performance requirements may require modification to tread water.This report considers the proposed 9X changes which affect the implementation of real-time Ada run-time systems, addresses why these features impact the run-time, and, where possible, suggests optimizations to minimize the performance impact on properly implemented applications.
About logical clocks for distributed systems
Authors: Michel Raynal
Venue: ACM SIGOPS Operating Systems Review (1992)

Memory space and processor time are basic resources when executing a program. But beside this implementation aspect (this time resource is necessary but does not belong to the program semantics), the concept of time presents a more fundamental facet in distributed systems namely causality relation between events. Put forward by Lamport in 1978, the logical nature of time is of primary importance when designing or analyzing distributed systems. This paper reviews three ways (linear time, vector time and matrix time) which have been proposed to capture causality between events of a distributed computation and which consequently allow to define logical time.
A simple display package for polynomials and rational functions in common Lisp
Authors: Richard J. Fateman, Derek T. Lai
Venue: ACM SIGSAM Bulletin (1991)

Users of computers for scientific and mathematical computation have become more aware of computer algebra systems through recent commercialization of the technology. However, the proprietary nature of most such systems makes the software unavailable to computer scientists and systems developers for "dissection" and for certain kinds of experiments or applications. In an attempt to provide appropriate software for such purposes, and especially for interaction in the Common Lisp environment, we have developed a simple mathematical display package. This program produces conventional notation - raised superscripts, fraction bars, and similar features, from an internal notation that is quite natural in Lisp. This module fits into the model begun by earlier programs at Berkeley consisting of a "clone" parser for one common proprietary system (the Mathematica (TM) language), and a simplifier for rational functions.The entire package is written in Common Lisp, and some of its main features are described in this document.
A message priority assignment algorithm for CAN based networks
Authors: Zhengou Wang, Huizhu Lu, Marvin Stone
Venue: Proceedings of the 1992 ACM annual conference on Communications (1992)

Controller Area Network (CAN) defines a very efficient medium access control protocol. This protocol solve conflict message transmission conflicts through message priorities, and results in a high channel utilization and short message delay for higher priority messages. An analytical model of the maximum message delay is presented. The maximum delay of different types of messages are formulated in terms of the message priority and the offered load of the system. Based on the maximum delay analysis, a message priority assignment algorithm is proposed. This algorithm is capable of generating an optimum priority assignment. A proof of correctness of the algorithm is also included in this paper.
What the user interface field thinks of the software copyright &ldquo;look and feel&rdquo; lawsuits (and what the law ought to do about it)
Authors: Pamela Samuelson, Robert F. J. Glushko
Venue: ACM SIGCHI Bulletin (1990)

The software copyright look and feel lawsuits have created a climate of uncertainty in the user interface design field [3, 4]. Although individuals may have opinions about how these lawsuits should be decided, it is difficult for them to know how representative their views are. This column will report on a survey on the user interface field's perspective on these lawsuits which was conducted at the sixth ACM Conference on Computer-Human Interaction (CHI '89) on May 2, 1989. This forum was chosen because the annual CHI meeting is the largest gathering of user interface researchers, designers, and developers-the people who have the most to gain or lose by the outcome of the look and feel controversy. (An in-depth report on the survey findings, which includes detailed statistical analysis, is available [4]). The column will compare the results of this survey with a report jointly written by 10 intellectual property scholars[1] concerning copyright protection for look and feel and other aspects of user interfaces. The CHI survey results are, in general, consistent with the scholars' conclusions based on copyright principles.[4] The legal experts see a basis in copyright law for denying copyright protection to look and feel, which is what the user interface field thinks would be in the field's best interest.
A database sequence: theory then practice
Authors: Kofi Apenyo
Venue: ACM SIGCSE Bulletin (1990)

A two-course upper-division undergraduate sequence in database systems offered by the computer science department at the Atlanta University Center is described. It is observed that the course contents of database program prepares students to fill the increasing number of database positions in industry while providing the broad foundation in the subject matter upon which students can build in graduate school. The program of database study consists of a core and an elective. The core covers database concepts, design, implementation, and processing. With the core as a prerequisite, the elective provides practical laboratory work that is dictated by requirements of the database industry. The database program described in this paper has been implemented at the Atlanta University Center in Atlanta, Georgia, by a JPL computer scientist with a NASA grant.
Designing database interfaces with DBface
Authors: Roger King, Michael Novak
Venue: ACM Transactions on Information Systems (TOIS) (1993)

DBface is a toolkit for designing interfaces to object-oriented databases. It provides users with a set of tools for building custom interfaces with minimal programming. This is accomplished by combining techniques from User Interface Management Systems (UIMS) with a built-in knowledge about the specific kinds of techniques used by object-oriented databases. DBface allows users to create graphical constructs and interactive techniques by taking advantage of an object-oriented database environment and tools. Not only can database tools be used for creating an interface, but information about the interface being built is stored within a database schema and is syntactically consistent with all other schema information. Thus, an interface can deal with data and schema information, including information about another interface. This allows for easy reusability of graphical constructs such as data representations.
Human computer interaction: an operational definition
Authors: Shaun Marsh
Venue: ACM SIGCHI Bulletin (1990)

This paper poses an operational definition for the term Human-Computer Interaction and distinguishes it from the term User Interface. Human-Computer Interaction includes several separate communication paths between the human and the computer's natural environment, the computer's own ergonomics, an operating environment, and an application environment. Each of these paths occur in parallel and have both a dialog and an interface component. A distinction is made between those dialog stages which allow multiple interpretations of symbols (soft-dialog) and those which allow only one interpretation for each symbol (hard-dialog). The term User Dialog includes only the soft-dialog stages, and the User Interface consists of the mechanisms for communicating the User Dialog.
An investigation into the application of a graphical, rule-based system utilizing reversible data structures as a possible model for human pedigree systems (abstract)
Authors: Charles Garner, Michael V. Doran, Herbert E. Longenecker,  Jr.
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

Pedigrees are widely used tools for genetic analysis of population, both human and animal. A pedigree consists of a finite and standardized set of symbols arranged in a two-dimensional format. The placement of each symbol is determined by the familial relationships in the represented groups. As such, the pedigree can be considered a pictograph. A pedigree also represents by inference the degree of genetic relationship between the individuals included. The analysis of genetic relationships, including risk assessment, inbreeding coefficients, linkage analysis, and other techniques, have been and continue to be vital components of the practice of both clinical and research-oriented genetics. A number of attempts have been made to computerize the production of pedigrees. These efforts have in common the ability to produce a pedigree from an extensive written family history. These systems are generally limited in their ability to represent complex pedigree structures. These complex structures result from two common types of events, inbreeding and multiple marriages. Also most systems lack an interactive user interface. The requisite data is entered into a textual database and the system generates the pedigree from the file. A graphic-oriented, real-time pedigree generator is not available at this time. This study will ascertain a suitable method for the computer representation of pedigree information, such that data in a graphic format can be represented in non-graphic format and vice versa. Control and presentation of the input into the graphical side of the system is critical. Only valid pedigrees should be allowed to be generated. The data structures chosen to accomplish this must be powerful enough to encode the desired complex relationships of interest. These structures must symbolically capture the additional genetic meaning. Also, the inferences drawn from the structures will aid in the analysis of the genetic relationships. This research will also investigate methods utilizing artificial intelligence techniques to perform the analysis and control of the pedigree.
A study of the Prather software metric (abstract)
Authors: Scott Moore, Ronald Curtis
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

Due to the increasing complexity of modern software code, we need ways of effectively measuring the difficulty of programs to detect problem code during development. Program metrics [Conte, 86] are a partial answer to this need. They offer us various ways of measuring the length, modularity, nesting, and data flow of software. The Prather metric, developed by Ronald E. Prather [Prather, 84], is a statement structure metric which measures statement nesting and control structures as a function of the simple statements they contain. For our research, we developed a program2 which takes Pascal programs as input and returns the Prather measures of the programs. Our project was to examine the Prather metric by comparing it with the Statement Count and McCabe measures, both are commonly used metrics, and see if there was a relationship between Prather and the other measures. If there is a correlation, this would show that Prather is not truly a unique measure, but it contains aspects of Statement Count or McCabe's measure. We also examined the use of the Prather metric as a cheating checker on student programs. We found that Prather may be better at picking out possible cheaters than Statement Count and McCabe's measure. We concluded that this was due to the nature of the Prather metric: it includes aspects of statement count and number of paths plus a measure of nesting.
A rational function arithmetic and simplification system in common Lisp
Authors: Tak W. Yan
Venue: ACM SIGSAM Bulletin (1991)

We describe a multivariate rational function (ratio of polynomials) arithmetic simplification system written in Common Lisp. These programs form one module in a sequence of packages written with an aim to develop an efficient, freely-distributed computer algebra system. In this report, we discuss the representation of rational functions in the system and the programs for rational addition, multiplication, and exponentiation. We also describe a package that converts between expressions in Lisp prefix form and the representation of rational expressions in the system.
A note on estimating the cardinality of the projection of a database relation
Authors: Ravi Mukkamala, Sushil Jajodia
Venue: ACM Transactions on Database Systems (TODS) (1991)

The paper by Ahad et al. [1] derives an analytical expression to estimate the cardinality of the projection of a database relation. In this note, we propose to show that this expression is in error even when all the parameters are assumed to be constant. We derive the correct formula for this expression.
Collaborative efforts
Authors: Peter G. Neumann
Venue: Communications of the ACM (1991)

This issue of Communications focuses on social and organizational influences governing collaborative uses of computers and communications. Here we review some of those influences from the perspectives of the risks involved.
Getting to the &ldquo;graphics&rdquo; in a graphics exercise
Authors: Dino Schweitzer, Linda Northrop
Venue: ACM SIGGRAPH Computer Graphics (1991)

An "algorithms" course in Computer Graphics relies heavily upon programming exercises to teach students the intricacies of graphics techniques. Such exercises should be substantial enough to avoid "trivializing" the problem and, at the same time, be interesting to the student. Unfortunately, substantial exercises also introduce a lot of overhead not directly related to the central graphics concepts being demonstrated. Overhead such as complex data structure definition and manipulation, external file input and output, low-level user interfaces, and graphics device drivers add a significant programming burden to the student. This overhead also detracts from the desired learning experience of the exercise. Various alternatives for solving this problem while maintaining the complexity of the exercise include: 1) designing the exercise to allow previous solution reusability, 2) providing a conceptual solution, 3) supplying actual code, both "white box" and "black box", and 4) making development tools and aids available, This paper will describe these different approaches, examine their advantages and disadvantages, and summarize our experience in the graphics course at the Air Force Academy.
Optimal Partitioning for Classification and Regression Trees
Authors: Philip A. Chou
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1991)

An iterative algorithm that finds a locally optimal partition for an arbitrary loss function, in time linear in N for each iteration is presented. The algorithm is a K-means-like clustering algorithm that uses as its distance measure a generalization of Kullback's information divergence. Moreover, it is proven that the globally optimal partition must satisfy a nearest neighbour condition using divergence as the distance measure. These results generalize similar results of L. Breiman et al. (1984) to an arbitrary number of classes or regression variables and to an arbitrary number of bills. Experimental results on a text-to-speech example are provided and additional applications of the algorithm, including the design of variable combinations, surrogate splits, composite nodes, and decision graphs, are suggested.
Explicit construction of natural bounded concentrators
Authors: Moshe Morgenstern
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

The first known direct construction for linear families of bounded concentrators is given. The construction is explicit, and the results are simple natural bounded concentrators.
Design of optimal distributed file systems: a framework for research
Authors: Uwe M. Borghoff
Venue: ACM SIGOPS Operating Systems Review (1992)

In this paper, the problem of determining an optimal location strategy for an individual program execution is considered. In addition, we propose a heuristic approach for the dynamic file allocation problem. In order to reduce the complexity of the optimization problems, a cluster-based approach is used.To access the data files of a distributed file system, a user initiates a program execution. Based on the current allocation of the program and data files as well as the knowledge about the characteristics of the programs, a first optimization calculates the optimal cluster for each individual program execution. The objective of this optimization is the minimization of the intercluster traffic of an individual program execution. Within the optimal cluster, a simple load-balancing strategy is used to determine the corresponding executing node.A second optimization looks for file allocations where the global intercluster traffic is minimized subject to the following constraints: minimal number of file copies, availability, and storage capacity.Experimental results showing the efficiency of the proposed algorithms are examined, and the implications of the model for the design of very large distributed file systems are discussed.
Dynamically balancing a binary tree (abstract)
Authors: Andrew T. Cable, Domenick J. Pinto
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

A binary tree is an excellent structure for storing sorted data. Searching is optimum if the tree is balanced. The following algorithm was developed with the help of some background information. This algorithm has proven to be an effective method of inserting data into a tree while dynamically rebalancing the tree when necessary.
A simulation study of forward error correction in ATM networks
Authors: Ernst W. Biersack
Venue: ACM SIGCOMM Computer Communication Review (1992)

If the packet loss rate in a network is higher than the loss rate requested by an application, the transport protocol must make up for the difference in loss rate. In high bandwidth delay-product networks the latency introduced by retransmission-based error recovery schemes may be too high for applications with latency constraints. In this case, Forward Error Correction (FEC) can be used. FEC allows recovery from loss without retransmission. The amount of loss recovered strongly depends on the loss behavior of the network. FEC works best if losses are dispersed.We use simulation to study the loss behavior of an output buffered multiplexer for three different traffic scenarios. Our results show how the loss behavior of the multiplexer is affected by the traffic mix and the statistics of the sources. The more bursty the sources are the larger the loss rate and the higher the probability that losses will occur in bursts. We then investigate the effectiveness of an FEC scheme that can recover a fixed number of lost packets within a block of consecutive packets. For a heterogeneous traffic scenario consisting of video and burst sources, this scheme reduces the loss rate for the video sources by several orders of magnitude.
New results with the Lincoln tied-mixture HMM CSR system
Authors: Douglas B. Paul
Venue: Proceedings of the workshop on Speech and Natural Language (1991)

The following describes recent work on the Lincoln CSR system. Some new variations in semiphone modeling have been tested. A very simple improved duration model has reduced the error rate by about 10% in both triphone and semiphone systems. A new training strategy has been tested which, by itself, did not provide useful improvements but suggests that improvements can be obtained by a related rapid adaptation technique. Finally, the recognizer has been modified to use bigram back-off language models. The system was then transferred from the RM task to the ATIS CSR task and a limited number of development tests performed. Evaluation test results are presented for both the RM and ATIS CSR tasks.
An optimal parallel algorithm for the maximal element problem (abstract)
Authors: C. Rhee, S. K. Dhall, S. Lakshmivarahan
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

Given a set (p1, p2, &hellip;, pn) of n points in a plane, a point pi dominates another point pj iff X (pi) &ge; X(pj) and Y (pi) &ge; Y(pj) where X (p) and Y (p) denote the coordinates of a point p. Our problem is to find the points which are dominated by no other point. These points are called maximal elements. In this abstract we suggest an &Ogr; (log n) parallel algorithm with &Ogr; (n) processors in the EREW parallel model which is weaker than CREW. (Note that most parallel algorithms in the literature use the power of CREW PRAM model.) The main idea is to reduce the problem to the parallel prefix problem [2]. Our algorithm runs as follows: First, from P = {pl, &hellip;, pn}, find a subset P' = {p1 &hellip;, pm }, where each point pi is dominated by no other point having the same X -coordinate aspi. This can be done in &Ogr; (log n) time with &Ogr; (n) processors in the EREW model applying the parallel sort algorithm by [1]. Next sort P' according to the X -coordinate of each point and store each Y -coordinate in an array A in the increasing order of the corresponding X -coordinate. Assume that the Y -coordinate of pi is stored in A [i ] for i = 1, 2, &hellip;, m. Then for each A [i ], find an index j such that i &le; j and A [j] &ge; A [k ] for each i &le; k &le; m. If i = j, then pi is one of the maximal elements. Th is can be done in &Ogr; (log n) time with &Ogr; (n) processors on the EREW parallel model by applying a parallel prefix algorithm |2|.
Efficient superscalar performance through boosting
Authors: Michael D. Smith, Mark Horowitz, Monica S. Lam
Venue: ACM SIGPLAN Notices (1992)

The foremost goal of superscalar processor design is to increase performance through the exploitation of instruction-level parallelism (ILP). Previous studies have shown that speculative execution is required for high instruction per cycle (IPC) rates in non-numerical applications. The general trend has been toward supporting speculative execution in complicated, dynamically-scheduled processors. Performance, though, is more than just a high IPC rate; it also depends upon instruction count and cycle time. Boosting is an architectural technique that supports general speculative execution in simpler, statically-scheduled processors. Boosting labels speculative instructions with their control dependence information. This labelling eliminates control dependence constraints on instruction scheduling while still providng full dependence information to the hardware. We have incorporated boosting into a trace-based, global scheduling algorithm that exploits ILP without adversely affecting the instruction count of a program. We use this algorithm and estimates of the boosting hardware involved to evaluate how much speculative execution support is really necessary to achieve good performance. We find that a statically-scheduled superscalar processor using a minimal implementation of boosting can easily reach the performance of a much more complex dynamically-scheduled superscalar processor.