ppxscal/embedding_network huggingface dataset:
An optimal service policy for buffer systems
Authors: Alexander Birman, H. Richard Gail, Sidney L. Hantler, Zvi Rosberg, Moshe Sidi
Venue: Journal of the ACM (JACM) (1995)

Consider a switching component in a packet-switching network, where messages from several incoming channels arrive and are routed to appropriate outgoing ports according to a service policy. One requirement in the design of such a system is to determine the buffer storage necessary at the input of each channel and the policy for serving these buffers that will prevent buffer overflow and the corresponding loss of messages. In this paper, a class of buffer service policies, called Least Time to Reach Bound (LTRB), is introduced that guarantees no overflow, and for which the buffer size required at each input channel is independent of the number of channels and their relative speeds. Further, the storage requirement is only twice the maximal length of a message in all cases, and as a consequence the class is shown to be optimal in the sense that any nonoverflowing policy requires at least as much storage as LTRB.
The LyriC language: querying constraint objects
Authors: Alexander Brodsky, Yoram Kornatzky
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

We propose a novel data model and its language for querying object-oriented databases where objects may hold spatial, temporal or constraint data, conceptually represented by linear equality and inequality constraints. The proposed LyriC language is designed to provide a uniform and flexible framework for diverse application realms such as (1) constraint-based design in two-, three-, or higher-dimensional space, (2) large-scale optimization and analysis, based mostly on linear programming techniques, and (3) spatial and geographic databases. LyriC extends flat constraint query languages, especially those for linear constraint databases, to structurally complex objects. The extension is based on the object-oriented paradigm, where constraints are treated as first-class objects that are organized in classes. The query language is an extension of the language XSQL, and is built around the idea of extended path expressions. Path expressions in a query traverse nested structures in one sweep. Constraints are used in a query to filter stored constraints and to create new constraint objects.
Reduced MVDs and minimal covers
Authors: Z. Meral Özsoyoğlu, Li-Yan Yuan
Venue: ACM Transactions on Database Systems (TODS) (1987)

Multivalued dependencies (MVDs) are data dependencies that appear frequently in the &ldquo;real world&rdquo; and play an important role in designing relational database schemes. Given a set of MVDs to constrain a database scheme, it is desirable to obtain an equivalent set of MVDs that do not have any redundancies. In this paper we define such a set of MVDs, called reduced MVDs, and present an algorithm to obtain reduced MVDs. We also define a minimal cover of a set of MVDs, which is a set of reduced MVDs, and give an efficient method to find such a minimal cover. The significance and properties of reduced MVDs are also discussed in the context of database design (e.g., 4NF decomposition) and conflict-free MVDs.
Gröbner and involutive bases for zero-dimensional ideals
Authors: Pedro A. García-Sánchez
Venue: ACM SIGSAM Bulletin (1995)

A new characterization of involutive systems is presented, which leads to a connection between Gr ouml;bner basis and involutive systems, and allows to construct, in an easy way, an involutive basis from a Gr ouml;bner basis.
Memory system performance of UNIX on CC-NUMA multiprocessors
Authors: John Chapin, A. Herrod, Mendel Rosenblum, Anoop Gupta
Venue: Proceedings of the 1995 ACM SIGMETRICS joint international conference on Measurement and modeling of computer systems (1995)

This study characterizes the performance of a variant of UNIX SVR4 on a large shared-memory multiprocessor and analyzes the effects of possible OS and architectural changes. We use a nonintrusive cache miss monitor to trace the execution of an OS-intensive multiprogrammed workload on the Stanford DASH, a 32-CPU CC-NUMA multiprocessor (CC-NUMA multiprocessors have cache-coherent shared memory that is physically distributed across the machine). We find that our version of UNIX accounts for 24% of the workload's total execution time. A surprisingly large fraction of OS time (79%) is spent on memory system stalls, divided equally between instruction and data cache miss time. In analyzing techniques to reduce instruction cache miss stall time, we find that replication of only 7% of the OS code would allow 80% of instruction cache misses to be serviced locally on a CC-NUMA machine. For data cache misses, we find that a small number of routines account for 96% of OS data cache stall time. We find that most of these misses are coherence (communication) misses, and larger caches will not necessarily help. After presenting detailed performance data, we analyze the benefits of several OS changes and predict the effects of altering the cache configuration, degree of clustering, and cache coherence mechanism of the machine. (This paper is available via http://wwwflash.stanford.edu.)
Fast evaluation of structured queries for information retrieval
Authors: Eric W. Brown
Venue: Proceedings of the 18th annual international ACM SIGIR conference on Research and development in information retrieval (1995)

Information retrieval systems are being challenged to manage larger and larger document collections. In an effort to provide better retrieval performance on large collections, more sophisticated retrieval techniques have been developed that support rich, structured queries. Structured queries are not amenable to previously proposed optimization techniques. Optimizing execution, however, is even more important in the context of large document collections. We present a new structured query optimization technique which we have implemented in an inference network-based information retrieval system. Experimental results show that query evaluation time can be reduced by more than half with little impact on retrieval effectiveness.
Analyzing multi-phase searching algorithms
Authors: Michael J. Bradley
Venue: ACM SIGCSE Bulletin (1996)

This paper presents a family of multi-phase searching algorithms that can enrich the discussion of searching algorithms in courses like CS13 Algorithms or CS7 Data Structures and Algorithm Analysis. These algorithms exhibit a natural but subtle relationship between the sequential search and binary search algorithms. They are non-trivial algorithms, yet they are easy to understand. Their complexity analysis is accessible, making use of differential calculus, Lagrange multipliers and base-2 logarithms. They have many practical applications and they appeal to students.
Algorithm 652: HOMPACK: a suite of codes for globally convergent homotopy algorithms
Authors: Layne T. Watson, Stephen C. Billups, Alexander P. Morgan
Venue: ACM Transactions on Mathematical Software (TOMS) (1987)

There are algorithms for finding zeros or fixed points of nonlinear systems of equations that are globally convergent for almost all starting points, i.e., with probability one. The essence of all such algorithms is the construction of an appropriate homotopy map and then tracking some smooth curve in the zero set of this homotopy map. HOMPACK provides three qualitatively different algorithms for tracking the homotopy zero curve: ordinary differential equation-based, normal flow, and augmented Jacobian matrix. Separate routines are also provided for dense and sparse Jacobian matrices. A high-level driver is included for the special case of polynomial systems.
A typed pattern calculus
Authors: Delia Kesner, Laurence Puel
Venue: Information and Computation (1996)

The theory of programming with pattern-matching function definitions has been studied mainly in the framework of first-order rewrite systems. We present a typed functional calculus that emphasizes the strong connection between the structures of whole pattern definitions and their types. In this calculus, type-checking guarantees the absence of runtime errors caused by non-exhaustive pattern-matching definitions. Its operational semantics is deterministic in a natural way, without the imposition of ad hoc solutions such as clause order or &ldquo;best fit&rdquo;. In the spirit of Curry-Howard homomorphism, we design the calculus as a computational interpretation of the Gentzen sequent proofs for the intuitionistic propositional logic. We prove the basic properties connecting typing and evaluation: subject reduction and strong normalization. We believe that this calculus offers a rational reconstruction of the pattern-matching features found in successful functional languages. &mdash;Authors' Abstract
Efficient instruction scheduling for delayed-load architectures
Authors: Steven M. Kurlander, Todd A. Proebsting, Charles N. Fischer
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1995)

A fast, optimal code-scheduling algorithm for processors with a delayed load of one instruction cycle is described. The algorithm minimizes both execution time and register use and runs in time proportional to the size of the expression-tree. An extension that spills registers when too few registers are available is also presented. The algorithm also performs very well for delayed loads of greater than one instruction cycle. A heuristic that schedules DAGs and is based on our optimal expression-tree-scheduling algorithm is presented and compared with Goodman and Hsu's algorithm Integrated Prepass Scheduling (IPS). Both schedulers perform well on benchmarks with small basic blocks, but on large basic blocks our scheduler outperforms IPS and is significantly faster.
What you need to know when you can't find your UNIX system administrator
Authors: Linda Mui
Venue:  (1995)

If you use UNIX, you know that it can be a technically challenging environment. And if you're like most users, you have a job to do aside from exploring your operating system -like analyzing that hot new stock, running another experiment, or typesetting another report. What happens when you have problems? What happens when the system slows to a crawl, when you can't get logged back in after a power failure, or when you've sent a file to the printer three times but have yet to find a printout? Your first choice for handling a problem might be to have the problem never occur. Your second choice might be to have someone else fix it, immediately. However, in the real world, sometimes you will have to investigate the problem and report it, and sometimes you will have to find an answer yourself. When You Can't Find Your UNIX System Administrator, part of our new What You Need to Know series, gives UNIX users tools for solving problems. It offers: Practical solutions for problems you're likely to encounter in logging in, running programs, sharing files, managing space resources, printing, and so on Just enough background on what's going on "behind the scenes" so that you can make sense of our suggestions, rather than simply memorizing keystrokes An explanation of how to present problems to your sys admin so that you're more likely to get quick, accurate support A list of the site-specific information to which you should have access, and a place to write it down A quick-ref card summarizing what to try first, second, third for commonly encountered problems The goal of this book is not to make you a guru in your own right. The goal of this book is to get you back to the job you'd rather be doing.
Computational geometry column 27
Authors: Joseph O'Rourke
Venue: ACM SIGACT News (1995)

The following new result is discussed: there is a perfect matching between the edges of any two triangulations of a finite set of points in the plane.
Slicing class hierarchies in C++
Authors: Frank Tip, Jong-Deok Choi, John Field, G. Ramalingam
Venue: ACM SIGPLAN Notices (1996)

This paper describes an algorithm for slicing class hierarchies in C++ programs. Given a C++ class hierarchy (a collection of C++ classes and inheritance relations among them) and a program P that uses the hierarchy, the algorithm eliminates from the hierarchy those data members, member functions, classes, and inheritance relations that are unnecessary for ensuring that the semantics of P is maintained.Class slicing is especially useful when the program P is generated from a larger program P' by a statement slicing algorithm. Such an algorithm eliminates statements that are irrelevant to a set of slicing criteria---program points of particular interest. There has been considerable previous work on statement slicing, and it will not be the concern of this paper. However, the combination of statement slicing and class slicing for C++ has two principal applications: First, class slicing can enhance statement slicing's utility in program debugging and understanding applications, by eliminating both executable and declarative program components irrelevant to the slicing criteria. Second, the combination of the two slicing algorithms can be used to decrease the space requirements of programs that do not use all the components of a class hierarchy. Such a situation is particularly common in programs that use class libraries.
Design and analysis of frame-based fair queueing: a new traffic scheduling algorithm for packet-switched networks
Authors: Dimitrios Stiliadis, Anujan Varma
Venue: ACM SIGMETRICS Performance Evaluation Review (1996)

In this paper we introduce and analyze frame-based fair queueing, a novel traffic scheduling algorithm for packet-switched networks. The algorithm provides end-to-end delay bounds identical to those of PGPS (packet-level generalized processor sharing), without the complexity of simulating the fluid-model system in the background as required in PGPS. The algorithm is therefore ideally suited for implementation in packet switches supporting a large number of sessions. We present a simple implementation of the algorithm for a general packet switch. In addition, we prove that the algorithm is fair in the sense that sessions are not penalized for excess bandwidth they received while other sessions were idle. Frame-based fair queueing belongs to a general class of scheduling algorithms, which we call Rate-Proportional Servers. This class of algorithms provides the same end-to-end delay and burstiness bounds as PGPS, but allows more flexibility in the design and implementation of the algorithm. We provide a systematic analysis of this class of schedulers and obtain bounds on their fairness.
Cluster Expansions for the Deterministic Computation of Bayesian Estimators Based on Markov Random Fields
Authors: Chi-hsin Wu, Peter C. Doerschuk
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

We describe a family of approximations, denoted by ¿cluster approximations,¿ for the computation of the mean of a Markov random field (MRF). This is a key computation in image processing when applied to the a posteriori MRF. The approximation is to account exactly for only spatially local interactions. Application of the approximation requires the solution of a nonlinear multivariable fixed-point equation for which we prove several existence, uniqueness, and convergence-of-algorithm results. Four numerical examples are presented, including comparison with Monte Carlo calculations.
What Can Be Computed Locally?
Authors: Moni Naor, Larry Stockmeyer
Venue: SIAM Journal on Computing (1995)

The purpose of this paper is a study of computation that can be done locally in a distributed network, where "locally" means within time (or distance) independent of the size of the network. Locally checkable labeling (LCL) problems are considered, where the legality of a labeling can be checked locally (e.g., coloring). The results include the following: There are nontrivial LCL problems that have local algorithms. There is a variant of the dining philosophers problem that can be solved locally. Randomization cannot make an LCL problem local; i.e., if a problem has a local randomized algorithm then it has a local deterministic algorithm. It is undecidable, in general, whether a given LCL has a local algorithm. However, it is decidable whether a given LCL has an algorithm that operates in a given time $t$. Any LCL problem that has a local algorithm has one that is order-invariant (the algorithm depends only on the order of the processor IDs).
A Nonlinear, SubGridscale Model for Incompressible Viscous Flow Problems
Authors: William J. Layton
Venue: SIAM Journal on Scientific Computing (1996)

We consider a nonlinear subgridscale model of the Navier--Stokes equations resulting in a Ladyzhenskaya-type system. The difference is that the power "$p$" and scaling coefficient $\mu(h) \doteq O(h^{\sigma})$ do not arise from macroscopic fluid properties and can be picked to ensure both $L^{\infty}$-stability and yet be of the order of the basic discretization error in smooth regions. With a properly scaled $p$-Laplacian-type artificial viscosity one can construct a higher-order method which is just as stable as first-order upwind methods.
The Design and Implementation of a Secure Auction Service
Authors: Matthew K. Franklin, Michael K. Reiter
Venue: IEEE Transactions on Software Engineering (1996)

We present the design and implementation of a distributed service for performing sealed-bid auctions. This service provides an interface by which clients, or "bidders," can issue secret bids to the service for an advertised auction. Once the bidding period has ended, the auction service opens the bids, determines the winning bid, and provides the winning bidder with a ticket for claiming the item bid upon. Using novel cryptographic techniques, the service is constructed to provide strong protection for both the auction house and correct bidders, despite the malicious behavior of any number of bidders and fewer than one-third of the servers comprising the auction service. Specifically, it is guaranteed that 1) bids of correct bidders are not revealed until after the bidding period has ended, 2) the auction house collects payment for the winning bid, 3) losing bidders forfeit no money, and 4) only the winning bidder can collect the item bid upon. We also discuss techniques to enable anonymous bidding.
Application and architectural bottlenecks in large scale distributed shared memory machines
Authors: Chris Holt, Jaswinder Pal Singh, John Hennessy
Venue: Proceedings of the 23rd annual international symposium on Computer architecture (1996)

Many of the programming challenges encountered in small to moderate-scale hardware cache-coherent shared memory machines have been extensively studied. While work remains to be done, the basic techniques needed to efficiently program such machines have been well explored. Recently, a number of researchers have presented architectural techniques for scaling a cache coherent shared address space to much larger processor counts. In this paper, we examine the extent to which applications can achieve reasonable performance on such large-scale, cache-coherent, distributed shared address space machines, by determining the problems sizes needed to achieve a reasonable level of efficiency. We also look at how much programming effort and optimization is needed to achieve high efficiency, beyond that needed at small processor counts. For each application, we discuss the main architectural bottlenecks that prevent smaller problem sizes or less optimized programs from achieving good efficiency. Our results show that while there are some applications that either do not scale or must be heavily optimized to do so, for most of the applications we studied it is not necessary to heavily modify the code or restructure algorithms to scale well upto several hundred processors, once the basic techniques for load balancing and data locality are used that are needed for small-scale systems as well. Programs written with some care perform well without substantially compromising the ease of programming advantage of a shared address space, and the problem sizes required to achieve good performance are surprisingly small. It is important to be careful about how data structures and layouts interact with system granularities, but these optimizations are usually needed for moderate-scale machines as well.
The class storage and retrieval system: enhancing reusability in object-oriented systems
Authors: Michael L. Nelson, Tilemahos Poulis
Venue: ACM SIGPLAN OOPS Messenger (1995)

Object-oriented programming (OOP) allows code developed for one class (the superclass) to be reused (via inheritance) in building another class (the subclass). Typical OOP systems provide a browser of some sort to allow the developer to peruse through libraries of classes, searching for an appropriate superclass to inherit from. However, as the number of classes involved grows from the tens to the hundreds to the thousands, the developer needs a very high level of knowledge about existing classes to minimize the search time. We have developed the Class Storage and Retrieval System (CSRS) which utilizes an underlying database management system to store and retrieve class definitions. Queries are then posed to the system to determine if any potential superclasses exist. The developer may then browse through a much smaller set of classes to determine if any are appropriate for the new application.
An approach to executable specifications, based on formal source_to_source conversion
Authors: Zhang Xinger
Venue: ACM SIGPLAN Notices (1995)

The paper proposes a new technique for executable specifications, which directly converts a specification into a program in a programming language by taking advantage of the idea of source_to_source conversion which is based on the rules defined formally and the canonical abstract syntax trees. The technique and the corresponding supporting system possess the following virtues: supporting rapid prototyping and getting the effects of prototypes well.
A taxonomy of architectures for synchronous groupware applications
Authors: John F. Patterson
Venue: ACM SIGOIS Bulletin (1995)

I offer a taxonomy for characterizing various architectures for synchronous groupware applications. Unlike teleconferencing per se, these are applications that have been implemented in such a way that users may simultaneously interact with the applications. The analysis rests on the following two premises: bull; The primary challenge tot synchronous groupware applications is to ensure state consistency,and bull; Applications may be divided into four levels of state.Figure 1 below depicts the four levels of state that I envision within any application. 4 The display state is the information that drives the user's display; the view state is the information that relates the user's display to the underlying information in the application; the model is the underlying information; and, the file is a persistent representation of the underlying information.Figure 15 below depicts the situation for a single user application. With multiple users there will be multiple displays, one per user. In synchronous groupware, one must ensure that these displays have access to some form of consistent state. There are two ways to achieve this consistency: by maintaining only one copy of the state or by maintaining multiple copies and using a consistency maintaining protocol. The next three sections discuss various architectures derived by applying these two approaches to consistency. The last section discusses a variety of residual issues that the evolving taxonomy does not easily address.