ppxscal/embedding_network huggingface dataset:
Compiling and optimizing for decoupled architectures
Authors: Nigel Topham, Alasdair Rawsthorne, Callum McLean, Muriel Mewissen, Peter Bird
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

Decoupled architectures provide a key to the problem of sustained supercomputer performance through their ability to hide large memory latencies. When a program executes in a decoupled mode the perceived memory latency at the processor is zero; effectively the entire physical memory has an access time equivalent to the processor's register file, and latency is completely hidden. However, the asynchronous functional units within a decoupled architecture must occasionally synchronize, incurring a high penalty. The goal of compiling and optimizing for decoupled architectures is to partition the program between the asynchronous functional units in such a way that latencies are hidden but synchronization events are executed infrequently. This paper describes a model for decoupled compilation, and explains the effectiveness of compilation for decoupled systems. A number of new compiler optimizations are introduced and evaluated quantitatively using the Perfect Club scientific benchmarks. We show that with a suitable repertiore of optimizations, it is possible to hide large latencies most of the time for most of the programs in the Perfect Club.
A tutorial on discrete-event modeling with simulation graphs
Authors: Arnold H. Buss
Venue: Proceedings of the 27th conference on Winter simulation (1995)

This tutorial is an introduction to simulation graphs for simulation modeling. The simulation graph methodology is a paradigm that directly models the future event list underlying the discrete event approach to simulation modeling. Simulation graphs have a minimalist design (a single type of node, two types of edges with up to three options), making them the ideal tool for rapid construction and representation of simulation models.
Algorithms for Square Roots of Graphs
Authors: Yaw-Ling Lin, Steven S. Skiena
Venue: SIAM Journal on Discrete Mathematics (1995)

The $n$th power ($n \geq 1$) of a graph $G = (V, E)$, written $G^n$, is defined to be the graph having $V$ as its vertex set with two vertices $u, v$ adjacent in $G^n$ if and only if there exists a path of length at most $n$ between them. Similarly, graph $H$ has an $n$th root $G$ if $G^n = H$. For the case of $n = 2$, we say that $G^2$ is the square of $G$ and $G$ is the square root of $G^2$. This paper presents a linear time algorithm for finding the tree square roots of a given graph and a linear time algorithm for finding the square roots of planar graphs. A polynomial time algorithm for finding the square roots of subdivision graphs, which is equivalent to the problem of the inversion of total graphs, is also presented. Further, the authors give a linear time algorithm for finding a Hamiltonian cycle in a cubic graph and prove the NP-completeness of finding the maximum cliques in powers of graphs and the chordality of powers of trees.
Some comments on software methodology versus CASE
Authors: Jing Ying, Zhijun He
Venue: ACM SIGSOFT Software Engineering Notes (1996)

This paper presents a personal viewpoint on the relationship between software methodology and Computer-aided Software Engineering ( CASE). Also several questions are put forward: Can CASE technology contribute to the high quality and efficient productivity of software product? Can CASE explore its largest power based on current software methodology? Or need current software methodology be revolutionized to a great degree? How should software researchers deal with the roles, significance and relationships among CASE, software methodology, software re-engineering, and so on? The answers to these questions will have vital effect on the development of software industry in the next century.
Checkpoint Space Reclamation for Uncoordinated Checkpointing in Message-Passing Systems.
Authors: Yi-Min Wang, Pi-Yu Chung, In-Jen Lin, W. Kent Fuchs
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

Uncoordinated checkpointing allows process autonomy and general nondeterministic execution, but suffers from potential domino effects and the associated space overhead. Previous to this research, checkpoint space reclamation had been based on the notion of obsolete checkpoints; as a result, a potentially unbounded number of nonobsolete checkpoints may have to be retained on stable storage. In this paper, we derive a necessary and sufficient condition for identifying all garbage checkpoints. By using the approach of recovery line transformation and decomposition, we develop an optimal checkpoint space reclamation algorithm and show that the space overhead for uncoordinated checkpointing is in fact bounded by $N(N+1)/2$ checkpoints where $N$ is the number of processes.Index Terms¿Fault tolerance, message-passing systems, uncoordinated checkpointing, rollback recovery, garbage collection.
How to integrate shared variables in distributed simulation
Authors: Horst Mehl, Stefan Hammes
Venue: ACM SIGSIM Simulation Digest (1995)

Although users may want to employ shared variables when they program distributed simulation applications, almost none of the currently existing distributed simulation systems does offer this facility. In this paper, we systematically present new algorithms which provide consistent shared variables for distributed simulation applications. Basically, our approach combines known techniques to realize distributed shared memory with simulation algorithms. As there are essentially two classes of distributed simulation algorithms---conservative and optimistic---we study shared variable algorithms for both of them and propose five new algorithms. Initial performance measurements of a prototype implementation are described. Potential performance degradation by the usage of shared variables is expected to depend to a high degree on the access behavior of the simulation application. Having the abstraction of shared variables available provides the user with a simple concept to design distributed simulation applications in the presence of inherent global data.
Autocorrelation of cycle times in semiconductor manufacturing systems
Authors: Alexander K. Schömig, Manfred Mittler
Venue: Proceedings of the 27th conference on Winter simulation (1995)

Due to the high complexity of semiconductor manufacturing systems simulation has become a useful tool for the performance analysis of these systems. However, there are some serious problems in analyzing simulation output data. For example, the quality of confidence intervals for certain performance measures is affected by correlations among the data. Furthermore, analyzing the correlation of simulation output data might give valuable hints for understanding the behavior of complex systems such as semiconductor manufacturing systems. In this paper we present examples where we have detected remarkable correlation phenomena, in the simulation output of semiconductor fabrication facilities caused by exo- or endogenous factors. Based on real specifications we examine several semiconductor manufacturing systems in steady state. First we calculate the autocorrelation function of the sequence of successive cycle times and then compute the corresponding frequency spectrum. By this means, periodicities in the simulation output data can efficiently be determined.
SPIN&mdash;an extensible microkernel for application-specific operating system services
Authors: Brian N. Bershad, Craig Chambers, Susan Eggers, Chris Maeda, Dylan McNamee, Przemysław Pardyak, Stefan Savage, Emin Gün Sirer
Venue: ACM SIGOPS Operating Systems Review (1995)

Application domains such as multimedia, databases, and parallel computing, require operating system services with high performance and high functionality. Existing operating systems provide fixed interfaces and implementations to system services and resources. This makes them inappropriate for applications whose resource demands and usage patterns are poorly matched by the services provided. The SPIN operating system enables system services to be defined in an application-specific fashion through an extensible microkernel. It offers applications fine-grained control over a machine's logical and physical resources through run-time adaptation of the system to application requirements.
A generic simulation package for organising outpatient clinics
Authors: Ray J. Paul, Jasna Kuljis
Venue: Proceedings of the 27th conference on Winter simulation (1995)

A computer based visual simulation model, made up of a complex data input component to define the clinic logistics, and an iconic visual simulation representation to show the effect of the policy has been built using a variety of commercial application packages. Visual simulation has made it possible to show interested parties in hospital outpatient clinics how the clinic appointment and operating policy can influence patient waiting time. The package has been tested at 20 tests sites in the United Kingdom, and interest is such that further modifications to the system have been proposed. A user support centre has been set up to give advice to any outpatient clinic in the U.K.'s National Health Service.
HyperFacs-building and using a digitized paper library
Authors: Andreas Myka, Ulrich Güntzer
Venue: ACM SIGWEB Newsletter (1995)

Though the number of electronically available text documents is steadily increasing, paper is still the most common medium. With regard to older documents, there is a huge heritage of material that cannot be converted manually into an adequate electronic form. With regard to texts that are created today, paper is still the primary publishing medium because people - either as authors or as readers - are more accustomed to it.
Optimal register assignment to loops for embedded code generation
Authors: David J. Kolson, Alexandru Nicolau, Nikil Dutt, Ken Kennedy
Venue: Proceedings of the 8th international symposium on System synthesis (1995)

Abstract: One of the challenging tasks in code generation for embedded systems is register assignment. When more live variables than registers exist, some variables are necessarily accessed from data memory. Because loops are typically executed many times and are often time-critical, good register assignment in loops is exceedingly important, since accessing data memory can degrade performance. The issue of finding an optimal register assignment to loops, one which minimizes the number of spills between registers and memory, has been open for some time. In this paper, we address this issue and present an optimal, but exponential, algorithm which assigns registers to loop bodies such that the resulting spill code is minimal. We also show that a heuristic modification performs as well as the exponential approach on typical loops from scientific code.
Byzantine Agreement in a Generalized Connected Network
Authors: S. C. Wang, Y. H. Chin, K. Q. Yan
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

Traditionally, the Byzantine Agreement (BA) problem is studied either in a fully connected network or in a broadcast network. A generalized network model for BA is proposed in this paper. A fully-connected network or a broadcast network is a special case of the new network architecture. Under the new generalized network model, the BA problem is reexamined with the assumption of malicious faults on both processors and transmission medium (TM), as opposed to previous studies which consider malicious faults on processors only. The proposed algorithm uses the minimum number of message exchanges, and can tolerate the maximum number of allowable faulty components to make each healthy processor reach a common agreement for the cases of processor failures, TM failures, or processor/TM failures. The results can also be used to solve the interactive consistency problem and the consensus problem.
The satanic notations: counting classes beyond #P and other definitional adventures
Authors: Lane A. Hemaspaandra, Heribert Vollmer
Venue: ACM SIGACT News (1995)

We explore the potentially "off-by-one" nature of the definitions of counting (#P versus #NP), difference (DP versus DNP), and unambiguous (UP versus UNP; FewP versus FewNP) classes, and make suggestions as to logical approaches in each case. We discuss the strangely differing representations that oracle and predicate models give for counting classes, and we survey the properties of counting classes beyond #P. We ask whether subtracting a #P function from a P function it is no greater than necessarily yields a #P function.
France: computer graphics education is blossoming
Authors: Francois Sillion
Venue: ACM SIGGRAPH Computer Graphics (1996)

Computer graphics is a very fast moving field throughout the world, and France is certainly no exception. While preparing this article, I discovered a half dozen graduate graphics courses that were offered for the first time this academic year. Considering the time that will elapse before this issue is sent to you, the reader, I will not claim to offer a complete view of computer graphics education in France. Rather, I would like to briefly explain the structure of the French education system, illustrate the recent evolution of the field and present a broad picture of the current offerings that revolve around computer graphics. More complete information on specific courses and programs, including some syllabi, can be found on-line as indicated below.Let me begin with the observation that French high schools are not typically very well equipped with computers. Therefore, we can consider that computer science (and computer graphics) education only begins at the higher education level. I shall start with a quick presentation of the French higher education and research system, this being necessary to understand the computer graphics education scene.
A Graph-Theoretic Game and its Application to the $k$-Server Problem
Authors: Noga Alon, Richard M. Karp, David Peleg, Douglas West
Venue: SIAM Journal on Computing (1995)

This paper investigates a zero-sum game played on a weighted connected graph $G$ between two players, the tree player and the edge player. At each play, the tree player chooses a spanning tree $T$ and the edge player chooses an edge $e$. The payoff to the edge player is $cost(T,e)$, defined as follows: If $e$ lies in the tree $T$ then $cost(T,e)=0$; if $e$ does not lie in the tree then $cost(T,e) = cycle(T,e)/w(e)$, where $w(e)$ is the weight of edge $e$ and $cycle(T,e)$ is the weight of the unique cycle formed when edge $e$ is added to the tree $T$. The main result is that the value of the game on any $n$-vertex graph is bounded above by $\exp(O(\sqrt{\log n \log\log n}))$. It is conjectured that the value of the game is $O(\log n)$. The game arises in connection with the $k$-server problem on a road network; i.e., a metric space that can be represented as a multigraph $G$ in which each edge $e$ represents a road of length $w(e)$. It is shown that, if the value of the game on $G$ is $Val(G,w)$, then there is a randomized strategy that achieves a competitive ratio of $k(1 + Val(G,w))$ against any oblivious adversary. Thus, on any $n$-vertex road network, there is a randomized algorithm for the $k$-server problem that is $k\cdot\exp(O(\sqrt{\log n \log\log n}))$ competitive against oblivious adversaries. At the heart of the analysis of the game is an algorithm that provides an approximate solution for the simple network design problem. Specifically, for any $n$-vertex weighted, connected multigraph, the algorithm constructs a spanning tree $T$ such that the average, over all edges $e$, of $cost(T,e)$ is less than or equal to $\exp(O(\sqrt{\log n \log\log n}))$. This result has potential application to the design of communication networks. It also improves substantially known estimates concerning the existence of a sparse basis for the cycle space of a graph.
Comprehension Grammars Generated from Machine Learning of Natural Languages
Authors: Patrick Suppes, Michael Böttner, Lin Liang
Venue: Machine Learning (1995)

We are developing a theory of probabilistic language learning in the context of robotic instruction in elementary assembly actions. We describe the process of machine learning in terms of the various events that happen on a given trial, including the crucial association of words with internal representations of their meaning. Of central importance in learning is the generalization from utterances to grammatical forms. Our system derives a comprehension grammar for a superset of a natural language from pairs of verbal stimuli like Go to the screw! and corresponding internal representations of coerced actions. For the derivation of a grammar no knowledge of the language to be learned is assumed but only knowledge of an internal language.We present grammars for English, Chinese, and German generated from a finite sample of about 500 commands that are roughly equivalent across the three languages. All of the three grammars, which are context-free in form, accept an infinite set of commands in the given language.
Namespaces: APL/W vs. APL2
Authors: Rexford H. Swain
Venue: Proceedings of the international conference on Applied programming languages (1995)

This paper describes and contrasts the implementation of namespaces in two popular combinations of APL dialects and platforms: IBM's APL2 (version 2, release 2) running under VM/CMS, and Dyadic's Dyalog APL/W (version 7.0) running under Microsoft Windows.In a traditional APL workspace, localization is the only mechanism available to isolate identifier names and values, and it is extremely potent. While a function that localizes a given name is executing, it is impossible to reference any other definition of the same name.Namespaces are a significant addition to an APL system. They provide a way to &ldquo;package&rdquo; a collection of objects (variables, defined functions, etc.), and insulate them from the traditional workspace. A namespace co-exists with the workspace, yet its object names and definitions are completely independent of the workspace. Namespaces can help to organize and hide complexity in workspaces, avoid name conflicts, and share code among applications.IBM has offered namespaces in APL2 since 1987, whereas Dyadic just recently introduced their facility. Both implementations provide encapsulation and name isolation within a workspace. But they use quite different methods to access objects in a namespace and store their initial definitions. The merits of each approach are discussed. An example is provided to illustrate how namespaces may be used to simplify the implementation and improve the functionality of workspace and function analysis tools.
Formal design constraints
Authors: Nils Klarlund, Jari Koistinen, Michael I. Schwartzbach
Venue: ACM SIGPLAN Notices (1996)

Large software systems are often built on system platforms that support or enforce specific characteristics of the source code or actual design. These characteristics are either captured informally in design guideline documents or in specialized design and implementation languages.In our view, both approaches are unsatisfactory. Informal descriptions do not allow automated analysis and lead to vague constraint descriptions. The language-based approach leads to different languages for different platforms and even for different versions of the same basic platform.Our approach is to describe and name the constraints separately in a design constraint language called CDL, which is based on an extraordinarily concise logic of parse trees. Designs are then annotated with the names of the constraints they are supposed to satisfy.We discuss how the design constraint language is integrated into a design language environment. We exhibit industrial and experimental evidence that our choice of design constraint language allows us to formalize naturally and succinctly common design characteristics.
Learning and generalization with Minimerror, a temperature-dependent learning algorithm
Authors: Bruno Raffin, Mirta B. Gordon
Venue: Neural Computation (1995)

We study the numerical performances of Minimerror, a recently introduced learning algorithm for the perceptron that has analytically been shown to be optimal both on learning linearly and nonlinearly separable functions. We present its implementation on learning linearly separable boolean functions. Numerical results are in excellent agreement with the theoretical predictions.
On ICSE's &ldquo;most influential&rdquo; papers
Authors: David Lorge Parnas
Venue: ACM SIGSOFT Software Engineering Notes (1995)

The International Conference on Software Engineering has established a tradition of looking back 10 conferences and selecting papers that have stood the test of time. The remarks below were prepared in connection an acceptance speech at ICSE 17 where two colleagues and I received the award for the best paper of ICSE 7.
Computer vulnerabilities: exploitation or avoidance
Authors: Peter G. Neumann
Venue: Communications of the ACM (1995)

The online Risks Forum has long been a hotbed for discussions of the relative merits of openness relating to the dissemination of knowledge about security vulnerabilities. The debate has now been rekindled, and is summarized here.
A Model for Software Product Quality
Authors: R. Geoff Dromey
Venue: IEEE Transactions on Software Engineering (1995)

A model for software product quality is defined. It has been formulated by associating a set of quality-carrying properties with each of the structural forms that are used to define the statements and statement components of a programming language. These quality-carrying properties are in turn linked to the high-level quality attributes of the International Standard for Software Product Evaluation ISO-9126. The model supports building quality into software, definition of language-specific coding standards, systematically classifying quality defects, and the development of automated code auditors for detecting defects in software.
Performance bounds in communication networks with variable-rate links
Authors: Kam Lee
Venue: ACM SIGCOMM Computer Communication Review (1995)

In most network models for quality of service support, the communication links interconnecting the switches and gateways are assumed to have fixed bandwidth and zero error rate. This assumption of steadiness, especially in a heterogeneous internet-working environment, might be invalid owing to subnetwork multiple-access mechanism, link-level flow/error control, and user mobility. Techniques are presented in this paper to characterize and analyze work-conserving communication nodes with varying output rate. In the deterministic approach, the notion of "fluctuation constraint," analogous to the "burstiness constraint" for traffic characterization, is introduced to characterize the node. In the statistical approach, the variable-rate output is modelled as an "exponentially bounded fluctuation" process in a way similar to the "exponentially bounded burstiness" method for traffic modelling. Based on these concepts, deterministic and statistical bounds on queue size and packet delay in isolated variable-rate communication server-nodes are derived, including cases of single-input and multiple-input under first-come-first-serve queueing. Queue size bounds are shown to be useful for buffer requirement and packet loss probability estimation at individual nodes. Our formulations also facilitate the computation of end-to-end performance bounds across a feedforward network of variable-rate server-nodes. Several numerical examples of interest are given in the discussion.
A remark on Algorithm 644: “A portable package for Bessel functions of a complex argument and nonnegative order”
Authors: D. E. Amos
Venue: ACM Transactions on Mathematical Software (TOMS) (1995)

Algorithm 644 computes all major Bessel functions of a complex argument and of nonnegative order. Single-precision routine CBESY and double-precision routine ZBESY are modified to reduce the computation time for the Y Bessel function by approximately 25% over a wide range of arguments and orders. Quick check (driver) programs that exercise the package are also modified to make tests more meaningful over larger regions of the complex plane.