ppxscal/embedding_network huggingface dataset:
POLSYS_PLP: A Partitioned Linear Product Homotopy Code for Solving Polynomial Systems of Equations
Authors: Wise Steven M., Sommese Andrew J., Watson Layne T.
Venue:  (1998)

Globally convergent, probability-one homotopy methods have proven to be very effective for finding all the isolated solutions to polynomial systems of equations. After many years of development, homotopy path trackers based on probability-one homotopy methods are reliable and fast. Now, theoretical advances reducing the number of homotopy paths that must be tracked, and in the handling of singular solutions, have made probablitiy-one homotopy methods even more practical. POLSYS_PLP consists of Fortran 90 modules for finding all isolated solutions of a complex coefficient polynomial system of equations. The package is intended to be used in conjunction with HOMPACK90 (algorithm 777), and makes extensive use of Fortran 90 derived data types to support a partitioned linear product (PLP) polynomial system structure. PLP structure is a generalization of m-homogeneous structure, whereby each component of the system can have a different m-homogeneous structure. POLSYS_PLP employs a sophisticated power series end game for handling singular solutions, and provide support for problem definition both at a high level and via hand-crafted code. Different PLP structures and their corresponding Bezout numbers can be systematically explored before committing to root finding.
Resource Allocation on Dynamic Conflict Graphs
Authors: Manhoi Choy, Ambuj K. Singh
Venue:  (1993)

The sharing of resources among processes in a distributed system leads to a conflict graph that may change with time. Resource allocation over a static conflict graph (also called the dining philosophers problem) has been studied extensively. We seek to solve resource allocation on dynamic conflict graphs by using existing algorithms that work only for static conflict graphs. In the process we define the notion of a snapshot of a dynamic graph, specify its properties, and show how it can be combined with static graph algorithms to yield efficient solutions for dynamic graphs.
Support for Object Placement in Wide-Area Heterogeneous Distributed Systems
Authors: John F. Karpovich
Venue:  (1996)

One of the open challenges in distributed computing systems is determining how to place tasks onto processors when they are needed (in the Legion project being developed at UVA the basic computational units are modelled as objects, so the problem is one of object placement). The placement decision is crucial because it determines the run-time behavior of an object, including performance, cost and whether it can run at all. Many approaches have been developed to address this problem in a distributed system environment, but it is our claim that these efforts do not take the proper approach for supporting the needs of the large wide area heterogeneous virtual computer systems we envision will exist in the future. In particular, the systems developed to date are inadequate because they 1) focus on solutions for a narrow set of application types, environments, or user objectives, and 2) often inadequately support the full complexity and features of large distributed systems. We propose to better support the placement process in distributed systems by employing a new approach. Our approach is different from previous ones in that we propose to design a framework for supporting a wide range of different placement problems, user objectives and placement algorithms, rather than building a system that supports a single placement technique. The goal of the framework is to provide programmers with the basic mechanisms to support each facet of the placement process which will enable them to implement the placement policies and techniques that meet their needs. On the other hand, individuals will be competing for limited resources owned by different people or organizations. Therefore, the framework must also contain mechanisms to enforce the policies of resource owners and to resolve conflicts between users. The research effort proposed here will focus on developing the mechanisms needed to support flexible distributed object placement. To identify the main components of the placement process and the key issues that must be resolved, we will first develop a general model of the placement process. Using this model, we will next develop and implement a framework to support object placement within the Legion system. Developing such a framework will lend insight into our placement model and will also provide a proof of concept for our approach. Finally, we will demonstrate the usefulness of our framework approach by mapping a range of placement algorithms to the Legion framework and evaluating the performance of several algorithms versus that provided by the system today.
Temporally coherent stereos improving performance through knowledge of motion
Authors: Vladimir Tucakov, David G. Lowe
Venue:  (1996)

This paper introduces the idea of temporally extending results of a stereo algorithm in order to improve the algorithm''s performance. This approach anticipates the changes between two consecutive depth maps resulting from the motion of the cameras. Uncertainties in motion are accounted for by computation of an ambiguity area and a resulting disparity range for each pixel. The computation is used to verify and refine the anticipated values, rather than calculate them without prior knowledge. The paper compares the performance of the algorithm under different constraints on motion. Speedups of up to 400\% are achieved without significant errors.
Pipeline Descriptions for Retargetable Compilers: A Decoupled Approach
Authors: Christopher W. Milner
Venue:  (1998)

A good optimizing compiler must have detailed information about the target processor''s execution pipeline in order to generate and schedule code with high levels of instruction-level parallelism. Current state-of-the-art pipeline descriptions are tediously constructed on an instruction-by-instruction basis. These descriptions often fail to capture important instruction scheduling constraints so artificial resources are introduced to enforce these constraints. The result is a pipeline description that is difficult to maintain and reuse; retargeting the compiler means retargeting each instruction and rethinking the purpose of each artificial resource. To address the above problems, the proposed research will develop a new, powerful approach for describing modern instruction pipelines by separating the pipeline description from the instruction set description. The proposed approach uses a graphical description of the pipeline and an accompanying annotation language to describe the relevant behavior of the machine''s execution pipeline. Using the descriptions of the pipeline and an existing description technique for instruction sets, it will be possible to generate instruction scheduler information automatically. Furthermore, this decoupling of the pipeline description from the instruction set description eases the burden of retargeting the compiler as new instruction set extensions and new pipeline implementations appear.
Local error estimator for stresses in 3D structural analysis
Authors: E. Florentin, L. Gallimard, P. Ladevèze, J. P. Pelle
Venue: Proceedings of the eighth international conference on The application of artificial intelligence to civil and structural engineering computing (2001)

This paper focuses on an a posteriori error estimator for F.E. approximations of 3D linear elasticity problems. The objective is to present the application of the new generation of error in constitutive relation to the calculation of the local error in classical tetrahedral elements. We show on examples whose solution is known analytically that the local error estimation gives satisfactory effectivity indexes.
TOWARDS A MORE COMPREHENSIVE THEORY OF LEARNING IN COMPUTERS (Ph.D. thesis)
Authors: Philip M. Long
Venue:  (1992)

We attempt to determine the theoretical boundaries of the ability of computers to learn. We consider several rigorous models of learning, aimed at addressing types of learning problems excluded from earlier models. In Part I, we consider learning dependencies between real-valued quantities in situations where the environment is assumed to be an adversary, operating within constraints that model the prior knowledge of the learner. While our assumptions as to the form of these dependencies is taken from previous work in statistics, this work is distinguished by the fact that the analysis is worst case. In Part II, we consider learning in situations in which the learner''s enviroment is assumed to be at least partially random. We consider methods for extending the tools for learning {0,1}-valued functions to apply to the learning of many-valued and real-valued functions. We also study the learning of {0,1}-valued functions in situations in which the relationship to be learned is gradually changing as learning is taking place.
Dodo: A User-level System for Exploiting Idle Memory in Workstation Clusters
Authors: Samir Koussih, Anurag Acharya, Sanjeev Setia
Venue:  (1998)

In this paper, we present the design and implementation of Dodo, an efficient user-level system for harvesting idle memory in off-the-shelf clusters of workstations. Dodo enables data-intensive applications to use remote memory in a cluster as an intermediate cache between local memory and disk. It requires no modifications to the operating system and/or processor firmware and is hence portable to multiple platforms. Further, the memory recruitment policy used by Dodo is designed to minimize any delays experienced by the owner of desktop machines whose memory is harvested by Dodo. Our implementation of Dodo is operational and currently runs on Linux 2.0.35. For communication, Dodo can use either UDP/IP or U-Net, the low-latency user-level network architecture developed by von Eicken et al. We evaluated the performance improvements that can be achieved by using Dodo for two real applications and three synthetic benchmarks. Our results show that speedups obtained for an application are highly dependent on its I/O access pattern and data set sizes. Significant speedups (between 2 and 3) were obtained for applications whose working sets are larger than the local memory on a workstation but smaller than aggregate memory available on the cluster and for applications that can benefit from the zero-seek nature of remote memory.
Implementation of an Enhanced Distributed Object Model using Actors
Authors: Challa Siva, Kafura Dennis
Venue:  (1998)

Most common object models of distributed object systems have a limited set of object-oriented features, lacking the advanced features of ''polymorphism'' (an abstraction mechanism that represents a quality or state of being able to assume different forms) and ''concurrency'' (the ability to have more than one thread of execution in an object simultaneously). The lack of support for advanced features is a serious limitation because it restricts the development of new components and limits reuse of existing components that use these advanced features. In this paper, the Interoperable Common Object Model (ICOM) centered on statically typed object-oriented languages is presented. The ICOM model is an attempt to elevate common object models (with the advanced features of polymorphism and concurrency) closer to the object models of statically typed object-oriented languages. Specific features of the ICOM model include: remote inheritance, method overloading, parameterized types, and guard methods. This paper focuses on how the actor model and reflection techniques are used to develop a uniform implementation framework for the ICOM object model in C++ and Modula-3. Two key features of the ICOM objects are discussed, remote inheritance and atomicity, along with the distributed compilation architecture of the ICOM framework emphasizing the role of the actor model in creating a simple underlying framework is emphasized.
Basic Block Distribution Analysis to Find Periodic Behavior and Simulation Points in Applications
Authors: Tomothy Sherwood, Erez Perelman, Brad Calder
Venue:  (2001)

Modern architecture research relies heavily on detailed pipeline simulation. The section of the program simulated is of great importance to the relevance and correctness of a study, since the behavior of the program can vary significantly during different phases of a program''s execution. In this paper we propose Basic Block Distribution Analysis as a semi-automatic approach for determining where to simulate in order to achieve a representative sample of the program. This approach is based upon using the profiles of a program''s code structure (basic blocks) to uniquely identify different phases of execution in the program. We show that this analysis accurately finds the periodic (cyclic) behavior exhibited during a program''s execution across several different architectural metrics (e.g., IPC, branch miss rate, cache miss rates, value misprediction, address misprediction, and reorder buffer occupancy). More importantly, our basic block analysis finds simulation points representative of the whole program''s execution for these different architectural features.
Why math?
Authors: Kim B. Bruce, Robert L. Scot Drysdale, Charles Kelemen, Allen Tucker
Venue: Communications of the ACM (2003)

The mathematical thinking, as well as the mathematics, in a computer science education prepares students for all stages of system development, from design to the correctness of the final implementation.
The Exact Number of Squares in Fibonacci Words
Authors: A. S. Fraenkel, J. Simpson
Venue:  (1997)

All our words (sequences) are binary. A square is a subword of the form uu (concatenation). Two squares are distinct if they are of different shape, not just translates of each other. Otherwise they are repeated. Fibonacci words are defined by f>sub<0>/sub< = 0, f>sub<1>/sub< = 1, f>sub<m>/sub< = f>sub<m-1>/sub<f>sub<m-2>/sub< for m ? 2. Let F>sub<m>/sub< = |f>sub<m>/sub<|. Then F>sub<0>/sub< = 1, F>sub<1>/sub< = 1, F>sub<m>/sub< = F>sub<m-1>/sub<+F>sub<m-2>/sub< (m ? 2) are the Fibonacci numbers. Let D(n) and R(n) be the exact number of Distinct and Repeated squares respectively in f>sub<n>/sub<. We prove: D(n) = 2(F>sub<n-2>/sub<-1) (n ? 5), which implies, asymptotically, D(n) = 2(2-j)F>sub<n>/sub<+o(1)&#x00A0;&#x00A0;&#x00A0; (2(2-j) < 0.7639), where j is the golden section. We also prove: R(n) = 4/>sub<5>/sub< nF>sub<n>/sub<-2/>sub<5>/sub< (n+6)F>sub<n-1>/sub<-F>sub<n-2>/sub<+n+1 (n ? 3). This yields R(n) = 2/>sub<5>/sub< (3-j)nF>sub<n>/sub<+O(F>sub<n>/sub<) = [(2(3-j))/( 5log>sub<2>/sub< j)]F>sub<n>/sub<log>sub<2>/sub< F>sub<n>/sub<+O(F>sub<n>/sub<) &#x00A0;&#x00A0;&#x00A0; ([(2(3-j))/( 5log>sub<2>/sub< j)] < 0.7962).
Optimal Algorithms to Embed Trees in a Point Set
Authors: Prosenjit Bose, Michael McAllister, Jack Snoeyink
Venue:  (1995)

We present optimal Theta(n log n) time algorithms to solve two tree embedding problems whose solution previously took quadratic time or more: rooted-tree embeddings and degree-constrained embeddings. In the rooted-tree embedding problem we are given a rooted-tree T with n nodes and a set of n points P with one designated point p and are asked to find a straight-line embedding of T into P with the root at point p. In the degree-constrained embedding problem we are given a set of n points P where each point is assigned a positive degree and the degrees sum to 2n-2 and are asked to embed a tree in P using straight lines that respects the degrees assigned to each point of P. In both problems, the points of P must be in general position and the embeddings have no crossing edges.
JN EXTERNAL API
Authors: Bruce R. Montague
Venue:  (1997)

The Application Program Interfaces (APIs) developed for the UCSC Java Nanokernel (JN) are described. These APIs provide an interface to a small embedded operating system developed at UCSC which runs on a `single-chip'' PC and supports a web server and web camera. These APIs include the APIs specified in the public JavaSoft JDK host porting interface (sys_api.h). These APIs enable execution of version 1.0.1 of the Java Virtual Machine (JVM). The implementation of these APIs in 1996 was independent of the Java Green Threads API implementation. The function, arguments, and return values of each API are described.
Caches As Filters: A Unifying Model for Memory Hierarchy Analysis
Authors: Dee A. B. Weikle, Kevin Skadron, Sally A. McKee, Wm Wulf
Venue:  (2000)

This paper outlines the new caches-as-filters framework for the analysis of caching systems, describing the functional filter model in detail. This model is more general than those introduced previously, allowing designers and compiler writers to understand why a cache exhibits a particular behavior, and in some cases indicating what compiler or hardware techniques must be employed to improve a cache hierarchy''s performance. Three components of the framework, the trace-specification notation, equivalence class concept, and new measures of cache performance, are described in previous publications. This paper extends the framework with a formal definition of the functional filter model and augments the trace-specification notation with additional constructs to describe conditionals and the effects of cache filtering. We then give detailed examples demonstrating the application of the model to a set of examples of a copy kernel, where each example represents a different equivalence class of traces.
Programming Constructs for Nonprocedural Languages
Authors: W. W. Wadge
Venue:  (1978)

In this paper how a pure denotative (nonprocedural) language based on the lambda calculus can be provided with purely denotative analogs of the various constructs - such as while loops, blocks, case statements and the like - of conventional imperative structured programming languages. They can be simulated quite adequately using only two simple tools: phrases, which are compound expressions not unlike blocks, and pronouns, special variables not unlike keywords between which certain relationships are `understood'' to hold.
A Reliability Model Incorporating Software Quality Factors
Authors: Sallie M. Henry, Dennis G. Kafura, Kevin A. Mayo, A. Yerneni, Steven A. Wake
Venue:  (1988)

In this paper we describe our initial work on a long-term project to develop and validate a reliability model and a new class of software complexity metrics which are related to this model. In contrast to previous "black box" approaches, the reliability model is novel because it incorporates knowledge about the system in the form of quantitative software complexity metrics. While the initial model uses existing software metrics a parallel effort in this project is investigating new classes of metrics, interface and dynamic metrics, which are useful in their own right but are also of particular relevance to the reliability model. The initial definitions of both the model and the metrics are given along with a description of the next research milestones.
On the Behavioral Inheritance of State-Based Objects
Authors: D. Harel, O. Kupferman
Venue:  (1999)

We consider the inheritance of state-based behavior in object-oriented analysis and design, as it arises, for example, in specifying behavior in the UML using statecharts. Our goal is to investigate the notion of behavioral conformity and the resulting substitutability of classes, whereby the inheritance mechanism is to retain original behaviors. This is a central issue of crucial importance to the modeling, design and verification of object-oriented systems. There are many deep and unresolved questions around inheritance, which cannot be addressed without a clear and rigorous picture of what exactly is meant by behavioral conformity, and how computationally complex it is to detect. We first define a basic computational model for object-oriented designs, and then define substitutability and inheritance in the linear and branching paradigms. We relate these to trace containment and Milner''s notion of simulation and deduce the complexity of some of the relevant algorithmic problems. The paper thus sets the stage for further research on behavioral inheritance.
A Multilevel Approach to Surface Response in Dynamically Deformable Models
Authors: Larry Palazzi, David R. Forsey
Venue:  (1994)

Discretized representations of deformable objects, based upon simple dynamic point-mass systems, rely upon the propagation of forces between neighbouring elements to produce a global change in the shape of the surface. Attempting to make such a surface rigid produces stiff equations that are costly to evaluate with any numerical stability. This paper introduces a new multilevel approach for controlling the response of a deformable object to external forces. The user specifies the amount of flexibility or stiffness of the surface by controlling how the applied forces propagate through the levels of a multi-resolution representation of the object. A wide range of surface behaviour is possible, and rigid motion is attained without resort to special numerical methods. This technique is applied to the displacement constraints method of Gascuel and Gascuel to provide explicit graduated control of the response of a deformable object to imposed forces.
Distributed Error Recovery for Continuous Media Data in Wide-Area Multicast
Authors: Matthew T. Lucas, Bert J. Dempsey, Alfred C. Weaver
Venue:  (1995)

This paper proposes new mechanisms to improve the quality of wide-area disseminations of time-sensitive streams, such as packet voice and video, from a single source to multiple receivers. Most current packet-switched networks provide no end-to-end quality-of-service guarantees for packet delay or loss, which can reduce the playback quality at receivers. Buffering at the multicast receivers can be used to minimize the playback degradation due to network delay variations. Addressing packet losses is more problematic. Solutions are constrained by the long latencies that may exist between the source and some of its receivers, the danger of simultaneous messages from a large number of receivers overwhelming network and endsystem resources (multicast implosion), and the limited bandwidth available on most wide-area links. Adapting the transmission rate of the multicast source to the available network bandwidth prevents excessive packet loss and protects the network from severe congestion due to any single source. However, rate control does not recover packet losses. To recover packets dropped by the network, the transmission of redundant information in the data stream (forward error correction) has been shown effective, but redundancy may consume significant network bandwidth and is inefficient when receivers have heterogeneous error rates. In this paper we develop and evaluate a novel retransmission-based error recovery strategy. Unlike previous reliable multicast protocols, our protocol relies on retransmissions from one receiver to another, thus avoiding the limitations of long latencies and multicast implosion inherent to source-driven retransmissions. Local retransmissions enables low latency recovery, uses wide-area bandwidth sparingly, and isolates the impact of losses to one area of the network. Simulation results presented in this paper demonstrate that this retransmission-based scheme can achieve distributed and effective recovery of packet losses for large receiver sets. The results show further that network resources are efficiently utilized and compare favorably with utilization under forward error correction.