ppxscal/embedding_network huggingface dataset:
The CRAFT Fortran programming model
Authors: Douglas M. Pase, Tom MacDonald, Andrew Meltzer
Venue: Scientific Programming (1994)

Many programming models for massively parallel machines exist, and each has its advantages and disadvantages. In this article we present a programming model that combines features from other programming models that (1) can be efficiently implemented on present and future Cray Research massively parallel processor (MPP) systems and (2) are useful in constructing highly parallel programs. The model supports several styles of programming: message-passing, data parallel, global address (shared data), and work-sharing. These styles may be combined within the same program. The model includes features that allow a user to define a program in terms of the behavior of the system as a whole, where the behavior of individual tasks is implicit from this systemic definition. (In general, features marked as shared are designed to support this perspective.) It also supports an opposite perspective, where a program may be defined in terms of the behaviors of individual tasks, and a program is implicitly the sum of the behaviors of all tasks. (Features marked as private are designed to support this perspective). Users can exploit any combination of either set of features without ambiguity and thus are free to define a program from whatever perspective is most appropriate to the problem at hand.
Analysis of multilevel graph partitioning
Authors: George Karypis, Vipin Kumar
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

Recently, a number of researchers have investigated a class of algorithms that are based on multilevel graph partitioning that have moderate computational complexity, and provide excellent graph partitions. However, there exists little theoretical analysis that could explain the ability of multilevel algorithms to produce good partitions. In this paper we present such an analysis. Weshow under certain reasonable assumptions that even if no refinement is used in the uncoarsening phase, a good bisection of the coarser graph is worse than a good bisection of the finer graph by at most a small factor. We also show that for planar graphs, the size of a good vertex-separator of the coarse graph projected to the finer graph (without performing refinement in the uncoarsening phase) is higher than the size of a good vertex-separator of the finer graph by at most a small factor.
Sparse functional stores for imperative programs
Authors: Bjarne Steensgaard
Venue: ACM SIGPLAN Notices (1995)

In recent years, the trend in program representations for imperative programs has been to make them more functional, or to make them more sparse. However, new sparse representations have been non-functional, and new functional representations have not been sparse in the presence of pointer operations. In this paper, we present a functional representation that is sparse even in the presence of pointer operations.Conventionally, a store is represented in a functional program representation by a single object&mdash;typically a mapping from locations to values. We show how such a store object may be fragmented into several objects, each representing part of the store. The result is a sparser representation, which has not only the usual benefit of directly linking producers to consumers, but which also for static program analysis often leads to smaller domains of abstract values for store objects. Store fragmentation corresponds to assignment factored SSA form (a factorization of SSA form introduced in this paper). We report on experiments with a thorough fragmentation based on a data flow points-to analysis and an intermediate level fragmentation based on an almost linear time complexity points-to analysis by type inference.
Reuse dimensions
Authors: Liesbeth Dusink, Jan van Katwijk
Venue: ACM SIGSOFT Software Engineering Notes (1995)

In recent years, there have been much publications on reuse. In order to bet an overview of the whole field and also a good impression of the state of the reuse art, we studied reuse literature of the last few years. As basis for comparison, we classified literature according to four (more or less orthogonal) dimensions, based on the actions and knowledge of the reuser, i.e. the software engineer. The dimensions are: actions to be taken to get an existing reusable item; knowledge to be applied to find an existing reusable item; actions to be taken to build the complete system needed; knowledge to be applied to get the complete system needed.The survey shows that research on reuse from the viewpoint of needed system, receives far less attention than research from the viewpoint of reusable artifacts. We expect reuse to live up to its promise if this topic is addressed was well.
Shore: combining the best features of OODBMS and file systems
Authors: CORPORATE The SHORE Team
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

Shore is a persistent object system under development at the University of Wisconsin that represents a merger of key features of object-oriented database (OODB) and file system technologies: Concurrency control and recovery and bulk operations on clustered data as in traditional databases; objects of widely varying sizes with individual identity, globally unique identifiers, and a rich object-oriented type system as in OODB systems; and an open architecture, a uniform, universal hierarchical name space, and controlled sharing of disks with reliably enforced ownership of data and space accounting. A more complete overview of the goals and structure of Share were presented at this conference last year [Carey et al, SIGMOD 94].
The info superhighway: for the people
Authors: Ben Shneiderman
Venue: Communications of the ACM (1995)

The opportunities are attractive, but some pavers of the Information Superhighway (ISH) are too eager to pour concrete. They risk making rough roads that will alienate the very users they seek. These technologically oriented ISH devotees may be building dramatic overpasses and painting stripes without figuring out where the highway should be going. I believe greater attention should be paid to identifying appropriate services, designing a consistent user interface, and developing a clearer model of the diverse user communities.
Learning Binary Relations Using Weighted Majority Voting
Authors: Sally A. Goldman, Manfred K. Warmuth
Venue: Machine Learning (1995)

In this paper we demonstrate how weighted majority voting with multiplicative weight updating can be applied to obtain robust algorithms for learning binary relations. We first present an algorithm that obtains a nearly optimal mistake bound but at the expense of using exponential computation to make each prediction. However, the time complexity of our algorithm is significantly reduced from that of previously known algorithms that have comparable mistake bounds. The second algorithm we present is a polynomial time algorithm with a non-optimal mistake bound. Again the mistake bound of our second algorithm is significantly better than previous bounds proven for polynomial time algorithms.A key contribution of our work is that we define a &ldquo;non-pure&rdquo; or noisy binary relation and then by exploiting the robustness of weighted majority voting with respect to noise, we show that both of our algorithms can learn non-pure relations. These provide the first algorithms that can learn non-pure binary relations.
Architectural mechanisms for explicit communication in shared memory multiprocessors
Authors: Umakishore Ramachandran, Gautam Shah, Anand Sivasubramaniam, Aman Singla, Ivan Yanasak
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

The goal of this work is to explore architectural mechanisms for supporting explicit communication in cache-coherent shared memory multiprocessors. The motivation stems from the observation that applications display wide diversity in terms of sharing characteristics and hence impose different communication requirements on the system. Explicit communication mechanisms would allow tailoring the coherence management under software control to match these differing needs and strive to provide a close approximation to a zero overhead machine from the application perspective. Toward achieving these goals, we first analyze the characteristics of sharing observed in certain specific applications. We then use these characteristics to synthesize explicit communication primitives. The proposed primitives allow selectively updating a set of processors, or requesting a stream of data ahead of its intended use. These primitives are essentially generalizations of prefetch and poststore, with the ability to specify the sharer set for poststore either statically or dynamically. The proposed primitives are to be used in conjunction with an underlying invalidation based protocol. Used in this manner, the resulting memory system can dynamically adapt itself to performing either invalidations or updates to match the communication needs. Through application driven performance study we show the utility of these mechanisms in being able to reduce and tolerate communication latencies.
The EM algorithm and information geometry in neural network learning
Authors: Shun-ichi Amari
Venue: Neural Computation (1995)

Hidden units play an important role in neural networks, although their activation values are unknown in many learning situations. The EM algorithm (statistical algorithm) and the em algorithm (information-geometric one) have been proposed so far in this connection, and the effectiveness of such algorithms is recognized in many areas of research. The present note points out that these two algorithms are equivalent under a certain condition, although they are different in general.
Determining Redundancy Levels for Fault Tolerant Real-Time Systems
Authors: Fuxing Wang, Krithi Ramamritham, John A. Stankovic
Venue: IEEE Transactions on Computers (1995)

Many real-time systems have both performance requirements and reliability requirements. Performance is usually measured in terms of the value in completing tasks on time. Reliability is evaluated by hardware and software failure models. In many situations, there are trade-offs between task performance and task reliability. Thus, a mathematical assessment of performance-reliability trade-offs is necessary toevaluate theperformance of real-time fault-tolerance systems. Assuming that the reliability of task execution is achieved through task replication, we present an approach that mathematically determines the replication factor for tasks. Our approach is novel in that it is a task schedule based analysis rather than a state based analysis as found in other models. Because we use a task schedule based analysis, we can provide a fast method to determine optimal redundancy levels, we are not limited to hardware reliability given by constant failure rate functions as in most other models, andwe hypothesize that we can more naturally integrate with on-line real-time scheduling than when state based techniques are used. In this work, the goal is to maximize the total performance index, which is a performance-related reliability measurement. We present a technique based on a continuous task model and show how it very closely approximates discrete models and tasks with varying characteristics.Index Terms¿Real-time systems, reliability, degradable systems, fault tolerance, functional variation, performability.
A Look-Ahead Block Schur Algorithm for Toeplitz-Like Matrices
Authors: Ali H. Sayed, Thomas Kailath
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

We derive a look-ahead recursive algorithm for the block triangular factorization of Toeplitz-like matrices. The derivation is based on combining the block Schur/Gauss reduction procedure with displacement structure and leads to an efficient block-Schur complementation algorithm. For an $n\times n$ Toeplitz-like matrix, the overall computational complexity of the algorithm is $O(rn^{2}+\frac{n^{3}}{t})$ operations, where $r$ is the matrix displacement rank and $t$ is the number of diagonal blocks. These blocks can be of any desirable size. They may, for example, correspond to the smallest nonsingular leading submatrices or, alternatively, to numerically well-conditioned blocks.
A rule-based message filtering system
Authors: Stephen Pollock
Venue: ACM Transactions on Information Systems (TOIS) (1988)

Much computerized support for knowledge workers has consisted of tools to handle low-level functions such as distribution, storage, and retrieval of information. However, the higher level processes of making decisions and taking actions with respect to this information have not been supported to the same degree. This paper describes the ISCREEN prototype system for screening text messages. ISCREEN includes a high-level interface for users to define rules, a component that screens text messages, and a conflict detection component that examines rules for inconsistencies. An explanation component uses text generation to answer user queries about past or potential system actions based on Grice's conversational maxims.
Metamodel applications using TERSM
Authors: Michael A. Zeimer, Jeffrey D. Tew
Venue: Proceedings of the 27th conference on Winter simulation (1995)

Tactical simulation models are often used to assess vulnerabilities and capabilities of combat systems and doctrines. Due to the complexity of tactical simulation models, it is often difficult to assess the relationship between input factors and the performance of the simulation model. To facilitate this type of assessment, simulation analysts often use the simulation model to empirically construct a black-box approximation of the causal and time dependent behavior of the simulation model. This type of approximation is known as a metamodel and can be viewed as a summary of the behavior of the simulation model. We demonstrate this technique in the context of an example using TERSM (Tactical Electronic Reconnaissance Simulation Model). The results indicate that metamodeling is applicable to tactical simulation models and that the technique has a wide range of uses.
Performance Characterization of the Tree Quorum Algorithm
Authors: Her-Kun Chang, Shyan-Ming Yuan
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

The tree quorum algorithm, which logically organizes the sites in a system to a tree structure, is an efficient and fault-tolerant solution for distributed mutual exclusion. In this paper, the performance characteristics of the tree quorum algorithm is analyzed. A refinement algorithm is proposed to refine a logical tree structure by eliminating nodes or subtrees which do not improve the performance. Thus the refined tree performs better than the original.Index Terms¿Distributed mutual exclusion, tree quorum algorithm, availability, communication cost.
Covariance and contravariance: conflict without a cause
Authors: Giuseppe Castagna
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1995)

In type-theoretic research on object-oriented programming, the issue of &ldquo;covariance versus contravariance&rdquo; is a topic of continuing debate. In this short note we argue that covariance and contravariance appropriately characterize two distinct and independent mechanisms. The so-called contravariance rule correctly captures the subtyping relation (that relation which establishes which sets of functions can replace another given set in every context). A covariant relation, instead, characterizes the specialization of code (i.e., the definition of new code which replaces old definitions in some particular cases). Therefore, covariance and contravariance are not opposing views, but distinct concepts that each have their place in object-oriented systems. Both can (and should) be integrated in a type-safe manner in object-oriented languages. We also show that the independence of the two mechanisms is not characteristic of a particular model but is valid in general, since covariant specialization is present in record-based models, although it is hidden by a deficiency of all existing calculi that realize this model. As an aside, we show that the &lgr; -calculus can be taken as the basic calculus for both an overloading-based and a record-based model. Using this approach, one not only obtains a more uniform vision of object-oriented type theories, but in the case of the record-based approach, one also gains multiple dispatching, a feature that existing record-based models do not capture
On optimal piggyback merging policies for video-on-demand systems
Authors: Charu Aggarwal, Joel Wolf, Philip S. Yu
Venue: Proceedings of the 1996 ACM SIGMETRICS international conference on Measurement and modeling of computer systems (1996)

A critical issue in the performance of a video-on-demand system is the I/O bandwidth required in order to satisfy client requests. A number of techniques have been proposed in order to reduce these bandwidth requirements. In this paper we concentrate on one such technique, known as adaptive piggybacking. We develop and analyze piggyback merging policies which are optimal over large classes of reasonable methods.
New directions for integrated circuit cards operating systems
Authors: Pierre Paradinas, Jean-Jacques Vandewalle
Venue: ACM SIGOPS Operating Systems Review (1995)

Integrated circuit cards or smart cards are now well-known. Applications such as electronic purses (cash units stored in cards), subscriber identification cards used in cellular telephone or access keys for pay-TV and information highways emerge in many places with millions of users. More services are required by applications providers and card holders. Mainly, new integrated circuit cards evolve towards non-predefined multi-purpose, open and multi-user applications. Today, operating systems implemented into integrated circuit cards cannot respond to these new trends. They have evolved from simple operating systems defining an hardware abstraction level up to file management systems or database management systems where the card behavior was defined once at the manufacturing level or by the card issuer. The needs for open and flexible card life cycle enabling to accommodate executable code loaded by different service providers require a new generation of smart cards. Operating systems based on object-oriented technologies are key components for future integrated circuit cards applications.
A soft systems approach to input distribution estimation for a non-stationary demand process
Authors: J. Harold Pardue, Jeffrey P. Landry, Thomas D. Clark,  Jr.
Venue: Proceedings of the 27th conference on Winter simulation (1995)

A soft systems methodology is undertaken to develop a design for a communications system to support a political campaign. The focus is on the methodology to estimate an input distribution for a SLAM-based simulation model. Two problems-the lack of referent system data and the expectation of non-stationary system demand-indicate a need for a soft systems approach. The results of this study suggest that the approach is effective for estimating an input distribution for simulation analysis. The case provides an example of the contrast between the soft systems and hard systems approaches.
Determining the last process to fail
Authors: Dale Skeen
Venue: ACM Transactions on Computer Systems (TOCS) (1985)

A total failure occurs whenever all processes cooperatively executing a distributed task fail before the task completes. A frequent prerequisite for recovery from a total failure is identification of the last set (LAST) of processes to fail. Necessary and sufficient conditions are derived here for computing LAST from the local failure data of recovered processes. These conditions are then translated into procedures for deciding LAST membership, using either complete or incomplete failure data. The choice of failure data is itself dictated by two requirements: (1) it can be cheaply maintained, and (2) it must afford maximum fault-tolerance in the sense that the expected number of recoveries required for identifying LAST is minimized.
A Micro Saint model of conveyor management strategies
Authors: K. Ronald Laughery
Venue: Proceedings of the 27th conference on Winter simulation (1995)

This paper discusses a simulation project that assessed the cost-effectiveness of modifying a highly complex conveyor system. An automobile component manufacturer was attempting to increase plant capacity by incorporating a dynamically programmable conveyor system. The question was whether the large investment would be justified by the increase in plant capacity. To answer this question, Micro Saint simulation models were constructed and validated for the baseline conveyor system. Then, these models were used to evaluate increases in throughput and utilization that would be gained by different scenario in 1) different conveyor programming strategies, 2) increases in conveyor demand, and 3) changes in conveyor demand variability. The results of the study indicated that plant capacity would be increased with a dynamically programmable conveyor systems, but perhaps not enough to warrant the investment.
A notation for malleable and interoperable coordination mechanisms for CSCW systems
Authors: Carla Simone, Monica Divitini, Kjeld Schmidt
Venue: Proceedings of conference on Organizational computing systems (1995)

In order to handle the high degree complexity that characterizes cooperative work in modern work settings, the articulation of the distributed activities requires a category of symbolic artifacts that stipulate and mediate articulation work. We call these artifacts 'coordination mechanisms'. From the evidence of sociological field studies, it is evident that computational coordination mechanisms must be malleable and interoperable. The paper describes a notation for constructing computational coordination mechanisms that meet these requirements.
The role of dynamic programming control structures in performance
Authors: Robert Bernecky
Venue: Proceedings of the international conference on Applied programming languages (1995)

Dynamic programming is used infrequently by APL programmers, in spite of its ability to reduce the computational effort required to solve many problems. This paper uses the String Shuffle problem as the basis for a comparison of brute force, recursive, and dynamic programming algorithms. Simple algorithms for each of these approaches are designed and evaluated, then individually optimized and re-evaluated, to show the benefits of dynamic programming.The dynamic programming algorithm is then recast to use flow control structures recently introduced into ISI J and APL*PLUS III. Use of control structures in conjunction with dynamic programming results in orders of magnitude performance improvement over brute force and naive recursive algorithms. APL*PLUS III control structures are shown to provide a performance improvement of up to 30% over GOTO-based loops.
Permuting In Place
Authors: Faith E. Fich, J. Ian Munro, Patricio V. Poblete
Venue: SIAM Journal on Computing (1995)

This paper addresses the fundamental problem of permuting the elements of an array of $n$ elements according to some given permutation. Our goal is to perform the permutation quickly using only a polylogarithmic number of bits of extra storage. The main result is an algorithm whose worst case running time is $O(n \log n)$ and that uses $O(\log n )$ additional $\log n$-bit words of memory. A simpler method is presented for the case in which both the permutation and its inverse can be computed at (amortised) unit cost. This algorithm requires $O(n \log n)$ time and $O(1)$ words in the worst case. These results are extended to the situation in which we are to apply a power of the permutation. A linear time, $O(1)$ word method is presented for the special case in which the data values are all distinct and are either initially in sorted order or will be when permuted.