ppxscal/embedding_network huggingface dataset:
The effectiveness of caches for vector processors
Authors: Jeffrey D. Gee, Alan Jay Smith
Venue: Proceedings of the 8th international conference on Supercomputing (1994)

Vector processors have typically used vector registers, interleaved memory, and pipelined access to data to provide sufficient memory system performance. Caches have been used mainly for instructions and scalar data, while vectors are usually uncached, presumably partially because of the belief that there is insufficient vector locality in these workloads. In this study we use memory address traces from an Ardent Titan to examine both reference locality and cache performance in a vector processing environment. Many of the Titan traces are from real vectorized applications which reference large amounts of data. We have found that vector references contain somewhat less temporal locality, but large amounts of spatial locality compared to instruction and scalar references. Cache miss ratios are found to be comparable to those measured and published previously for various non-vectorized workloads. We provide analyses of trace behavior with regard to parameters of interest to cache designers. Calculations based on our measured miss ratios indicate that caches will improve average access times, which in turn can be expected to translate into significant improvements in machine performance. Arguments suggesting otherwise are discussed and considered.
Inferential security in individual computing environments
Authors: Cleopas O. Angaye, Steven C. Hansen
Venue: ACM SIGICE Bulletin (1994)

Inference is a powerful act of the mind that combines known data using human judgement in such a way as to extend knowledge, i.e., creation of new information. People can use the information stored in a computer or the behavior of the computer to gain knowledge for which they have no authorization. This is considered a security or confidentiality breach and is the subject of the area of computer security known as inferential security. This paper provides an overview of inferential security breach and some of the known closed form methods for perpetrating this type of security breach. Some of the concerns for the user of individual computing environments (ICE's) are addressed.
Designing programs to check their work (abstract)
Authors: Manuel Blum
Venue: Proceedings of the 1993 ACM SIGSOFT international symposium on Software testing and analysis (1993)

Designing Programs to Check Their Work Professor Manuel Blurn Department of EECS UC Berkeley and International Computer Science Institute Berkeley, California Abstract Students, engineers, programmers... are all expected to check their work. Computer programs are not. There are several reasons for this: 1. Computer hardware almost never makes errors -- but that fails to recognize that programmers do! 2. Programs are hard enough to write without having to also write program checkers for them -- but that is the price of increased confidence! 3. There is no clear notion what constitutes a good checker. Indeed, the same students and engi-neers who are cautioned to check their work are rarely informed what it is that makes a proce-dure good for doing so -- but that is just the sort of problem that computer science should be able to solve! In my view, the lack of correctness checks in programs is an oversight. Programs have bugs that could perfectly well be caught by such checks. This talk urges that programs be written to check their work, and outlines a promising and rigorous approach to the study of this fascinating new area.
Dynamic impact analysis: a cost-effective technique to enforce error-propagation
Authors: Tarak Goradia
Venue: ACM SIGSOFT Software Engineering Notes (1993)

This paper introduces dynamic impact analysis as a cost-effective technique to enforce the error-propagation condition for detecting a fault. The intuition behind dynamic impact analysis is as follows. In a specific test-case, if an execution of a syntactic component has a strong impact on the program output and if the output is correct, then the value of that component-execution is not likely to be erroneous. To capture this intuition in a theoretical framework the notion of impact is formally defined and the concept of impact strength is proposed as a quantitative measure of the impact. In order to provide an infrastructure supporting the computation of impact strengths, program impact graphs and execution impact graphs are introduced. An empirical study validating the computation of impact strengths is presented. It is shown that the impact strengths computed by dynamic impact analysis provide reasonable estimates for the error-sensitivity with respect to the output except when the impact is via one or more error-tolerant components of the program. Potential applications of dynamic impact analysis in the area of mutation testing and dynamic program slicing are discussed.
A Virtual Cockpit for a Distributed Interactive Simulation
Authors: W. Dean McCarty, Steven Sheasby, Philip Amburn, Martin R. Stytz, Chip Switzer
Venue: IEEE Computer Graphics and Applications (1994)

We developed the virtual cockpit as an inexpensive flight simulator, using off-the-shelf equipment. This system functions as a component of a distributed interactive simulation. Any flight simulator has three principal tasks: image display, image generation, and flight dynamics. We built the flight simulator, the virtual cockpit, using a head-mounted display (HMD) to display the out-the-window imagery and the cockpit interior. The virtual cockpit consists of a Silicon Graphics workstation and supporting hardware components, such as an HMD and position tracker. The software falls into three areas by function: flight dynamics and cockpit instruments; network interface (either SimNet or DIS PDUs); and display of the out-the-window view. The virtual cockpit developed uses a multiprocessor Silicon Graphics Iris (the 4D/440VGXT) connected to a Polhemus Laboratories fiber-optic head-mounted display, a Polhemus magnetic head tracker and a hands-on-throttle-and-stick (HOTAS) by Thrustmaster. The software uses the AT and T C++ translator and the Silicon Graphics C compiler running under Irix 4.0.5. a Unix operating system. We use Software Systems' MultiGen to create the geometric models and the terrain database.
The role of APL and J in high-performance computation
Authors: Robert Bernecky
Venue: ACM SIGAPL APL Quote Quad (1993)

Although multicomputers are becoming feasible for solving large problems, they are difficult to program: Extraction of parallelism from scalar languages is possible, but limited. Parallelism in algorithm design is difficult for those who think in von Neumann terms. Portability of programs and programming skills can only be achieved by hiding the underlying machine architecture from the user, yet this may impact performance on a specific host.APL, J, and other applicative array languages with adequately rich semantics can do much to solve these problems. The paper discusses the value of abstraction and semantic richness, performance issues, portability, potential degree of parallelism, data distribution, process creation, communication and synchronization, frequency of program faults, and clarity of expression. The BLAS are used as a basis for comparison with traditional supercomputing languages.
A simple straightforward method for software development
Authors: Donald V. Steward
Venue: ACM SIGSOFT Software Engineering Notes (1993)

This article presents a method that greatly simplifies software development even while providing a richer description of the system being developed. One tree like structure captures the configuration of the product throughout the whole development process. This avoids the much criticized 'chasm' between analysis and design [2] and gives complete traceability and measurability from requirements to code. It provides for the rich description of interfaces particularly important for large systems. Although the system is documented as a tree structure. it can be used with top-down, bottom-up, object oriented and formal styles of development. It can be tried and evaluated quite easily using a conventional outline processor, which allows one to show just the level of detail of whatever part one wishes to see. This article will start out by showing how you can use the basic method, then successively add more features to demonstrate the ramifications of this simple idea.
Object-oriented communication server for banking applications (abstract)
Authors: Ion Cartiant
Venue: ACM SIGPLAN OOPS Messenger (1993)

In France, there is a generalized file transfer method used for customer-bank information exchange, on X25 networks and on telephone switched lines (BSC 2780/3780 like protocol). It is used by (almost) all France-based banks, and thousands of customers. RONDO is an 00 file server, supporting these protocols. It was developed in BORLAND C++, with TURBO VISION graphics library. Without the included files, the overall code lines, as reported by the project manager, are 22,000. The server works fine on a 386 based PC, DOS 5.0. RONDOs capabilities are: support up to four file transfers on public switched communication lines, and four file transfers on X25 virtual circuits, simultaneously, on-line verification of incoming files for format correctness, and on-line surveillance and administration. The demonstrations purposes are: present a real-time application of the 00 technology, including interrupt control and encapsulation of an OEM X25 driver (not 00); present a brand new user comfort for DOS communication applications; real time information about incoming transfers; optional operator zoom on different monitors: status, statistics, log, traffic, trace, file verification; configuration control; client diagnosis and support; present the internal objects grouped in 4 domains: communication, administration, user interface, and system extension. Through graphic objects, this technology brings a spectacular new comfort to DOS users with less overhead than in graphical environments. For developers it provides reusable objects and simple building logic.
The Zebra striped network file system
Authors: John H. Hartman, John K. Ousterhout
Venue: Proceedings of the fourteenth ACM symposium on Operating systems principles (1994)

Zebra is a network file system that increases throughput by striping file data across multiple servers. Rather than striping each file separately, Zebra forms all the new data from each client into a single stream, which it then stripes using an approach similar to a log-structured file system. This provides high performance for writes of small files as well as for reads and writes of large files. Zebra also writes parity information in each stripe in the style of RAID disk arrays; this increases storage costs slightly but allows the system to continue operation even while a single storage server is unavailable. A prototype implementation of Zebra, built in the Sprite operating system, provides 4--5 times the throughput of the standard Sprite file system or NFS for large files and a 20%-3x improvement for writing small files.
Restructuring a parallel simulation to improve cache behavior in a shared-memory multiprocessor: the value of distributed synchronization
Authors: David R. Cheriton, Hendrik A. Goosen, Hugh Holbrook, Philip Machanick
Venue: ACM SIGSIM Simulation Digest (1993)

Synchronization is a significant cost in many parallel programs, and can be a major bottleneck if it is handled in a centralized fashion using traditional shared-memory constructs such as barriers. In a parallel time-stepped simulation, the use of global synchronization primitives limits scalability, increases the sensitivity to load imbalance, and reduces the potential for exploiting locality to improve cache behavior. This paper presents the results of an initial one-application study quantifying the costs and performance benefits of distributed, nearest neighbors synchronization. The application studied, MP3D, is a particle-based wind tunnel simulation. Our results for this one application on current shared-memory multiprocessors show a significant decrease in synchronization time using these techniques. We prototyped an application-independent library that implements distributed synchronization. The library allows a variety of parallel simulations to exploit these techniques without increasing the application programming beyond that of conventional approaches.
Cyclic Arcs in PG(2, q)
Authors: L. Storme, H. Van Maldeghem
Venue: Journal of Algebraic Combinatorics: An International Journal (1994)

B.C. Kestenband &lsqb;9&rsqb;, J.C. Fisher, J.W.P. Hirschfeld, and J.A. Thas &lsqb;3&rsqb;, E. Boros, and T. Sz&ouml;nyi &lsqb;1&rsqb; constructed complete (q2 &minus; q + l)-arcs in PG(2, q2), q &ge; 3. One of the interesting properties of these arcs is the fact that they are fixed by a cyclic protective group of order q2 &minus; q + 1. We investigate the following problem: What are the complete k-arcs in PG(2, q) which are fixed by a cyclic projective group of order k? This article shows that there are essentially three types of those arcs, one of which is the conic in PG(2, q), q odd. For the other two types, concrete examples are given which shows that these types also occur.
Complexity aspects of various semantics for disjunctive databases
Authors: Thomas Eiter, Georg Gottlob
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

This paper addresses complexity issues for important problems arising with disjunctive databases. In particular, the complexity of inference of a literal and a formula from a propositional disjunctive database under a variety of well-known disjunctive database semantics is investigated, as well deciding whether a disjunctive database has a model under a particular semantics. The problems are located in appropriate slots of the polynomial hierarchy.
Cost-effective object space management for hardware-assisted real-time garbage collection
Authors: Kelvin D. Nilsen, William J. Schmidt
Venue: ACM Letters on Programming Languages and Systems (LOPLAS) (1992)

Modern object-oriented languages and programming paradigms require finer-grain division of memory than is provided by traditional paging and segmentation systems. This paper describes the design of an OSM (Object Space Manager) that allows partitioning of real memory on object, rather than page, boundaries. The time required by the OSM to create an object, or to find the beginning of an object given a pointer to any location within it, is approximately one memory cycle. Object sizes are limited only by the availability of address bits. In typical configurations of object-oriented memory modules, one OSM chip is required for every 16 RAM chips. The OSM serves a central role in the implementation of a hardware-assisted garbage collection system in which the worst-case stop-and-wait garbage collection delay ranges between 10 and 500 &mgr;sec, depending on the system configuration.
Separating and intersecting spherical polygons: computing machinability on three-, four-, and five-axis numerically controlled machines
Authors: Lin-Lin Chen, Shuo-Yan Chou, Tony C. Woo
Venue: ACM Transactions on Graphics (TOG) (1993)

We consider the computation of an optimal workpiece orientation allowing the maximal number of surfaces to be machined in a single setup on a three-, four-, or five-axis numerically controlled machine. Assuming the use of a ball-end cutter, we establish the conditions under which a surface is machinable by the cutter aligned in a certain direction, without the cutter's being obstructed by portions of the same surface. The set of such directions is represented on the sphere as a convex region, called the visibility map of the surface. By using the Gaussian maps and the visibility maps of the surfaces on a component, we can formulate the optimal workpiece orientation problems as geometric problems on the sphere. These and related geometric problems include finding a densest hemisphere that contains the largest subset of a given set of spherical polygons, determining a great circle that separates a given set of spherical polygons, computing a great circle that bisects a given set of spherical polygons, and finding a great circle that intersects the largest or the smallest subset of a set of spherical polygons. We show how all possible ways of intersecting a set of n spherical polygons with v total number of vertices by a great circle can be computed in O(vn log n) time and represented as a spherical partition. By making use of this representation, we present efficient algorithms for solving the five geometric problems on the sphere.
Object-oriented user interfaces (abstract)
Authors: Dave Collins
Venue: ACM SIGPLAN OOPS Messenger (1993)

Object-Oriented User Interfaces Dave Collins, IBM, The principles of objects, polymorphism, classes, and inheritance can apply to the end users external view of a user interface, just as it can apply to the language that is used to implement it. This tutorial shows how to design (not implement) a user interface that is truly object-oriented. It gives guidance on the design of the externals of object-oriented user interfaces, and shows how developers can capitalize on the isomorphism between the users conceptual model of the interface and the constructs provided by object-oriented programming languages. The tutorial exposes a (perhaps surprisingly) deep analogy between object-oriented programming languages and object-oriented user interfaces. This analogy is valuable because it can be used to map external user interface design in a clear and natural way onto object-oriented application frameworks. The tutorial is illustrated with historical examples, many on videotape.
Constructing specification morphisms
Authors: Douglas R. Smith
Venue: Journal of Symbolic Computation (1993)

Specification morphisms underlie the refinement of algebraic specifications and provide the logical foundations for algorithm and data structure design. We present four techniques for formally, even mechanically, constructing specification morphisms. The first two techniques, verifying a manually constructed signature morphism and composition of specification morphisms are well-known. The remaining two techniques exploit the axioms of the source specification to help infer the translation of sort and function symbols from the source specification. The third, unskolemization, finds the translation of a function symbol by replacing occurrences of it in an axiom by an existentially quantified variable. A constructive proof of the translated axiom yields a witness to the existential that serves as the desired translation of the function symbol. The fourth technique, connections between specifications, allows the transfer of structure from one specification morphism to another. The unskolemization and connection techniques arose as abstractions from the algorithm design tactics implemented in the KIDS program transformation system (Smith (1990)). They suggest a more general approach to providing mechanized support for applying design knowledge expressed axiomatically.
Fixed-precision estimation of join selectivity
Authors: Peter J. Haas, Jeffrey F. Naughton, S. Seshadri, Arun N. Swami
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

We compare the performance of sampling-based procedures for estimation of the selectivity of an equijoin. While some of the procedures have been proposed in the database sampling literature, their relative performance has never been analyzed. A main result of this paper is a partial ordering that compares the variability of the estimators for the different procedures after an arbitrary fixed number of sampling steps. Prior to the current work, it was also unknown whether these fixed-step estimation procedures can be extended to asymptotically efficient fixed-precision estimation procedures. Our second main result is a general method for such an extension and a proof that the method is valid for all the estimation procedures under consideration. Finally, we show that, under reasonable assumptions on sampling costs, the partial ordering on the variability of the fixed-step estimation procedures implies a partial ordering on the cost of the corresponding fixed-precision estimation procedures. These results lead to a new algorithm for fixed-precision estimation of the selectivity of an equijoin. The algorithm appears to be the best available when there are no indices on the join key. Our results can be extended to general select-join queries.
Efficient recursive subtyping
Authors: Dexter Kozen, Jens Palsberg, Michael I. Schwartzbach
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

Subtyping in the presence of recursive types for the &lgr;-calculus was studied by Amadio and Cardelli in 1991 [1]. In that paper they showed that the problem of deciding whether one recursive type is a sub-type of another is decidable in exponential time. In this paper we give an O(n2) algorithm. Our algorithm is based on a simplification of the definition of the subtype relation, which allows us to reduce the problem to the emptiness problem for a certain finite automaton with quadratically many states. It is known that equality of recursive types and the covariant Bo&uml;hm order can be decided efficiently by means of finite automata. Our results extend the automata-theoretic approach to handle orderings based on contravariance.
Signatures for a network protocol stack: a systems application of Standard ML
Authors: Edoardo Biagioni, Robert Harper, Peter Lee, Brian G. Milnes
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

Advanced programming languages such as Standard ML have rarely been used for systems programming tasks such as operating systems and network communications. In order to understand more fully the requirements of systems programming, we have implemented a suite of industry-standard network communication protocols in a completely type-safe extension of Standard ML. While the implementation has only recently become operational, we already observe acceptable communications throughput. We make careful use of the Standard ML modules system, with the core component of the implementation being a signature which is generic to all communications protocols. This generic protocol is then specialized for specific protocols, and these are implemented by functors parameterized by generic protocols. This leads naturally to a layered system structure and also provides an important and useful &ldquo;mix-and-match&rdquo; capability in composing protocols into complex networking systems.We have found the advanced features of Standard ML, in particular the modules system, static typing, and higher-order functions, to be extremely useful in building complex communications systems. The type compatibility of the various components of a system is guaranteed by the compiler. Furthermore, we find it significant that most of the information needed to understand the structure and interactions in our code can be obtained from a study of the signatures alone. Perhaps most important is that we have been able to use the expressive power of Standard ML modules to give concrete expression to previously ad hoc system-structuring concepts developed by other researchers in the field of network communications. For language designers and implementors, our experience has also pointed out specific areas for further work that may lead to advanced languages that are useful for systems programming.