ppxscal/embedding_network huggingface dataset:
Parallel Pointer-Based Join Algorithms in Memory-mapped Environments
Authors: Peter A. Buhr, Anil K. Goel, Naomi Nishimura, Prabhakar Ragde
Venue: Proceedings of the Twelfth International Conference on Data Engineering (1996)

Three pointer-based parallel join algorithms are presented and analyzed for environments in which secondary storage is made transparent to the programmer through memory mapping. Buhr, Goel, and Wai have shown that data structures such as B-Trees, R-Trees and graph data structures can be implemented as efficiently and effectively in this environment as in a traditional environment using explicit I/O. Here we show how higher-order algorithms, in particular parallel join algorithms, behave in a memory mapped environment. A quantitative analytical model has been developed to conduct performance analysis of the parallel join algorithms. The model has been validated by experiments.
Dynamic Routing of Bandwidth Guaranteed Multicasts with Failure Backup
Authors: Murali S. Kodialam, T. V. Lakshman
Venue: Proceedings of the 10th IEEE International Conference on Network Protocols (2002)

This paper presents a new algorithm for dynamic routing of bandwidth guaranteed multicast tunnels with failure backup. The multicast routing problem arises in many contexts such as the routing of point-to-multipoint label switched paths in Multi-Protocol Label Switched (MPLS) Networks, and the provision of bandwidth guaranteed services under the "hose" model [4]. Failure backup implies that when a multicast tree is set-up alternate backup paths be also set-up so that the multicast is unaffected by single link or node failures. For dynamic routing, the multicast routing requests arrive one-by-one and there is no a priori knowledge regarding future requests. We believe that this is the first paper that addresses the issue of multicast routing with failure backup. Each multicast request consists of a source s, a set of receivers R, and a bandwidth requirement b. Offline multicast routing algorithms cannot be used since they require a priori knowledge of all multicast tunnel requests that are to be routed. The newly developed algorithm is an on-line algorithm that generates a reserved-bandwidth multicast tree with additional backup links that make the multicast tree resilient to single element failures inthe network. It shares backup bandwidth when possible and only uses link usage information obtainable in a distributed manner.
Visual software requirements definition environment
Authors: Atsushi Ohnishi, Norihiro Tokuda
Venue: Proceedings of the 21st International Computer Software and Applications Conference (1997)

The authors propose a visual software requirements definition method including describing a visual software requirements specification (SRS) with a visual requirements language and executing the SRS. The method proposed provides a describer for defining both the shape and semantics of icons to specify the requirements as he imagines. The method also provides for describing an icons' movements as a scenario description. This scenario enables an execution of the SRS with animation. The describer can confirm his requirements by checking the animation. Furthermore the paper describes a supporting method of visual software requirements definition by multiple developers via a network system.
Early Quantification and Partitioned Transition Relations
Authors: Ramin Hojati, Sriram C. Krishnan, Robert K. Brayton
Venue: Proceedings of the 1996 International Conference on Computer Design, VLSI in Computers and Processors (1996)

Hardware systems are generally specified as a set of interacting finite state machines (FSMs). An important problem in formal verification using Binary Decision Diagrams (BDDs) is forming the transition relation of the product machine. This problem reduces to conjuncting (or multiplying) the BDDs representing the transition relations of the individual machines, and then existentially quantifying out the set of input and output variables. The resulting graph is called the product graph. Computing the set of reachable states of the product graph is the central verification problem. In this paper, we discuss two related problems. The early quantification problem is the problem of interleaving multiplication of a set of BDDs with the quantification of a set of variables so that the size of the largest BDD encountered is minimized. We show that an abstraction of this problem is NP-complete, and provide heuristic solutions for it. In some cases, the size of the BDD representing the transition relation of the product graph is too large. The partitioned transition relations problem deals with partially combining the BDDÆs and quantifying as many variables as possible, so that the time for computing the set of reachable states of the product graph is minimized. We offer heuristic solutions to this problem based on our algorithms for early quantification. The algorithms have been implemented and good experimental results have been achieved.
Investigating Large Software System Evolution: The Linux Kernel
Authors: Ettore Merlo, Michel Dagenais, P. Bachand, J. S. Sormani, S. Gradara, Giuliano Antoniol
Venue: Proceedings of the 26th International Computer Software and Applications Conference on Prolonging Software Life: Development and Redevelopment (2002)

Large multi-platform, multi-million lines of codes software systems evolve to cope with new platform or to meet user ever changing needs. While there has been several studies focused on the similarity of code fragments or modules, few studies addressed the need to monitor the overall system evolution. Meanwhile, the decision to evolve or to refactor a large software system needs to be supported by high level information, representing the system overall picture, abstracting from unnecessary details.This paper proposes to extend the concept of similarity of code fragments to quantify similarities at the release/system level. Similarities are captured by four software metricsrepresentative of the commonalities and differences within and among software artifacts.To show the feasibility of characterizing large software system with the new metrics, 365 releases of the Linux kernel were analyzed. The metrics, the experimental results as well as the lessons learned are presented in the paper.
Exploiting Application Tunability for Efficient, Predictable Parallel Resource Management
Authors: Fangzhe Chang, Vijay Karamcheti, Zvi M. Kedem
Venue: Proceedings of the 13th International Symposium on Parallel Processing and the 10th Symposium on Parallel and Distributed Processing (1999)

Parallel computing is becoming increasing central and mainstream, driven both by the widespread availability of commodity SMP and high-performance cluster platforms, as well as the growing use of parallelism in general-purpose applications such as image recognition, virtual reality, and media processing. In addition to performance requirements, the latter computations impose soft real-time constraints, necessitating efficient, predictable parallel resource management. In this paper, we propose a novel approach for increasing parallel system utilization while meeting application soft real-time deadlines. Our approach exploits the application tunability found in several general-purpose computations. Tunability refers to an application's ability to trade off resource requirements over time, while maintaining a desired level of output quality. We first describe language extensions to support tunability in the Calypso system, then characterize the performance benefits of tunability, using a synthetic task system to systematically identify its benefits. Our results show that application tunability is convenient to express and can significantly improve parallel system utilization for computations with predictability requirements.
Dynamic Interval Routing on Asynchronous Rings
Authors: Danny Krizanc, Flaminia L. Luccio, Rajeev Raman
Venue: Proceedings of the 13th International Symposium on Parallel Processing and the 10th Symposium on Parallel and Distributed Processing (1999)

We consider the problem of routing in an asynchronous dynamically changing ring of processors using schemes that minimize the storage space for the routing information. In general, applying static techniques to a dynamic network would require significant re-computation. Moreover, the known dynamic techniques applied to the ring lead to inefficient schemes.In this paper we introduce a new technique, Dynamic Interval Routing, and we show trade offs between the stretch, the adaptation cost and the size of the update messages used by routing schemes based upon it.We give three algorithms for rings of maximum size N: the first two are deterministic, one with adaptation cost zero but stretch N/2, the other with adaptation cost O(N) messages of O(log N) bits and stretch 1. The third algorithm is randomized, uses update messages of size O(k log N), has adaptation cost O(k) and expected stretch 1+1/k, for any k>=1. All schemes require O(log N) bits per node for the routing information and all messages headers are of O(log N) bits.
An Application of Directory Service Markup Language (DSML) for Role-Based Access Control (RBAC)
Authors: Dongwan Shin, Gail-Joon Ahn, Joon S. Park
Venue: Proceedings of the 26th International Computer Software and Applications Conference on Prolonging Software Life: Development and Redevelopment (2002)

Directory service markup language (DSML) prescribes how to manipulate directory servicesinformation in XML, and thus it facilitates sharing of directory information as XML fragments among XML-based applications. In this paper, we describe how to leverage DSML for role-based access control on XML-based web applications which often need collaboration within or beyond a single enterprise boundary. Compared with previous works in this area, we show that our approach can solve the problems of a previous LDAP-oriented solution. We discuss the security architecture based upon server-pull model and its components. We also demonstrate the feasibility of our approach through a proof-of-concept implementation. Finally, several issues from our experience are discussed as well.
Generalized Compact Knapsacks, Cyclic Lattices, and Efficient One-Way Functions from Worst-Case Complexity Assumptions
Authors: Daniele Micciancio
Venue: Proceedings of the 43rd Symposium on Foundations of Computer Science (2002)

We study a generalization of the compact knapsack problem for arbitrary rings: given m = O(log n) ring elements a_1 , \ldots ,a_m \varepsilon R and a target value b\varepsilon R, find coefficients x_1 , \ldots ,x_m \varepsilon X (where X is a subset of R of size 2^n) such thatsum {a_i } x_i= b. The computational complexity of this problem depends on the choice of the ring R and set of coefficients X. This problem is known to be solvable in quasi polynomial time when R is the ring of the integers and X is the set of small integers { 0, \ldots ,2^n- 1}. We show that if R is an appropriately chosen ring of modular polynomials and X is the subset of polynomials with small coefficients, then the compact knapsack problem is as hard to solve on the average as the worst case instance of approximating the covering radius (or the length of the shortest vector, or various other well known lattice problems) of any cyclic lattice within a polynomial factor. Our proof adapts, to the cyclic lattice setting, techniques initially developed by Ajtai for the case of general lattices.
On-line Handwritten Signature Verification using Hidden Markov Model Features
Authors: Ramanujan S. Kashi, Jianying Hu, W. L. Nelson, W. Turin
Venue: Proceedings of the 4th International Conference on Document Analysis and Recognition (1997)

A method for the automatic verification of on-line handwritten signatures using both global and local features is described. The global and local features capture various aspects of signature shape and dynamics of signature production. We demonstrate that with the addition to the global features of a local feature based on the signaturelikelihood obtained from Hidden Markov Models (HMM), the performance of signature verification improves significantly. The current version of the program has 2.5% equal error rate. At the 1% false rejection (FR) point, the addition of the local information to the algorithm with only global features reduced the false acceptance (FA) rate from 13% to 5%.
Army software metrics training
Authors: Fred M. Hall
Venue: Proceedings of the 21st International Computer Software and Applications Conference (1997)

The experience of the Army Metrics Training Program has been that most software development managers do not recognize or use the software metrics which are already available in their programs. The content of the Army Metrics course focuses on use of the "standard" Army set of metrics. However, the course material is presented in a workshop format, in which the student group discusses the standard metric definition in terms of their program applications. The objective is to teach the tailoring process to define software metrics in terms of each student's management objectives and the structure of their program. The metrics tailoring process is structured by allowing by the students to define their own software measurement issues, including: how will measurement information be useful to my program in our existing management structure? How do I implement a measurement program without additional resources? What existing information and management systems can provide software measurement data?.
Animating Virtual Humans Using Hand Postures
Authors: Fabio Wilhelms Damasio, Soraia Raupp Musse
Venue: Proceedings of the 15th Brazilian Symposium on Computer Graphics and Image Processing (2002)

Interaction between human and computer has been used in large scale in computer graphics and virtual reality. This paper presents a system to provide interaction between user and virtual humans. The system uses a Data Glove and an Artificial Neural Network System responsible for the recognition of Hand Postures.
Coherent Block Data Transfer in the FLASH Multiprocessor
Authors: John Heinlein, Kourosh Gharachorloo, Robert P. Bosch,  Jr., Mendel Rosenblum, Anoop Gupta
Venue: Proceedings of the 11th International Symposium on Parallel Processing (1997)

A key goal of the Stanford FLASH project is to explore the integration of multiple communication protocols in a single multiprocessor architecture. To achieve this goal, FLASH includes a programmable node controller called MAGIC, which contains an embedded protocol processor capable of implementing multiple protocols. In this paper we present a specialized protocol for block data transfer integrated with a conventional cache coherence protocol. Block transfer forms the basis for message passing implementations on top of shared memory, occurs in important workloads such as databases, and is frequently used by the operating system. We discuss the issues that arise in designing a fully integrated protocol and its interactions with cache coherence. Using microbenchmarks, MPI communication primitives, and an application running on the operating system, we compare our protocol with standard bcopy and bcopy augmented with prefetches. Our results show that integrated block transfer can accelerate communication between nodes while off-loading the task from the main processor utilizing the network more efficiently, and reducing the associated cache pollution. Given the aggressive support for prefetching in FLASH, prefetched bcopy is able to achieve competitive performance in many cases but lacks the other three advantages of our protocol.
An Architecture Workbench for Multicomputers
Authors: Andy D. Pimentel, Louis 0. Hertzberger
Venue: Proceedings of the 11th International Symposium on Parallel Processing (1997)

The large design space of modern computer architectures calls for per$ormance modelling tools to facilitate the eval- uation of different alternatives. In this papet; we give an overview of the Mermaid multicomputer simulation envi- ronment. This environment allows the evaluation of a wide range of architectural design tradeoffs while delivering rea- sonable simulation per$ormance. To achieve this, simula- tion takes place at a level of abstract machine instructions rather than at the level of real instructions. Moreoven a less detailed mode of simulation is also provided. So when ac- curacy is not the primary objective, this simulation mode can yield high simulation eflciency. As a consequence, Mermaid makes both fast prototyping and accurate evalu- ation of multicomputer architectures feasible.
Titan: A High-Performance Remote Sensing Database
Authors: Chialin Chang, Bongki Moon, Anurag Acharya, Carter Shock, Alan Sussman, Joel H. Saltz
Venue: Proceedings of the Thirteenth International Conference on Data Engineering (1997)

There are two major challenges for a high performance remote sensing database. First, it must provide low latency retrieval of very large volumes of spatio temporal data. This requires effective declustering and placement of a multidimensional dataset onto a large disk farm. Second, the order of magnitude reduction in data size due to post processing makes it imperative, from a performance perspective, that the post processing be done on the machine that holds the data. This requires careful coordination of computation and data retrieval. The paper describes the design, implementation and evaluation of Titan, a parallel shared nothing database designed for handling remote sensing data. The computational platform for Titan is a 16 processor IBM SP-2 with four fast disks attached to each processor. Titan is currently operational and contains about 24 GB of AVHRR data from the NOAA-7 satellite. The experimental results show that Titan provides good performance for global queries and interactive response times for local queries.
Distributed automatic test pattern generation with a parallel FAN algorithm
Authors: Stefan Radtke, Jens Bargfrede, Walter Anheier
Venue: Proceedings of the 1995 International Conference on Computer Design: VLSI in Computers and Processors (1995)

The generation of test patterns for digital circuits is known as an NP hard problem. Due to the backtracking mechanism in the sequential algorithms for test pattern generation it is difficult to speed up the process. In this paper we present a parallel formulation of the FAN algorithm implemented on a heterogeneous cluster of workstations. Two different methods are used to take into account easy- and hard-to-detect faults. We show the strategies for our parallel implementations as well as implementation details. Linear speedups are shown with the results. Furthermore we introduce a new method for test vector compaction using a genetic algorithm. This results in smaller test sets compared to traditional methods. The reader should be familiar with notations of the FAN algorithm.
Precise exception handling for a self-timed processor
Authors: William F. Richardson, Erik Brunvand
Venue: Proceedings of the 1995 International Conference on Computer Design: VLSI in Computers and Processors (1995)

Self-timed systems structured as multiple concurrent processes and communicating through self-timed queues are a convenient way to implement decoupled computer architectures. Machines of this type can exploit instruction level parallelism in a natural way, and can be easily modified and extended. However, providing a precise exception model for a self-timed micropipelined processor can be difficult, since the processor state does not change at uniformly discrete intervals. We present a precise exception method implemented for Fred, a self-timed, decoupled, pipelined computer architecture with out-of-order instruction completion.
Context-Dependent Interpretations of Linguistic Terms in Fuzzy Relational Databases
Authors: Weining Zhang, Clement T. Yu, Bryan Reagan, Hiroshi Nakajima
Venue: Proceedings of the Eleventh International Conference on Data Engineering (1995)

Approaches are proposed to allow fuzzy terms to be interpreted according to the context within which they are used. Such an interpretation is natural and useful. A query-dependent interpretation is proposed to allow a fuzzy term to be interpreted relative to a partial answer of a query. A scaling process is used to transform a pre-defined meaning of a fuzzy term into on appropriate meaning in the given context. Sufficient conditions are given for a nested fuzzy query with RELATIVE quantifiers to be unnested for an efficient evaluation. An attribute-dependent interpretation is proposed to model the applications in which the meaning of a fuzzy term in an attribute must be interpreted with respect to values in other related attributes. Two necessary and sufficient conditions for a tuple to have a unique attribute-dependent interpretation are provided. We describe an interpretation system that allows queries to be processed based on the attribute-dependent interpretation of the data. Two techniques, grouping and shifting, are proposed to improve the implementation.
Binary decision diagrams on network of workstation
Authors: Rajeev K. Ranjan, Jagesh V. Sanghavi, Robert K. Brayton, Alberto L. Sangiovanni-Vincentelli
Venue: Proceedings of the 1996 International Conference on Computer Design, VLSI in Computers and Processors (1996)

The success of all binary decision diagram (BDD) based synthesis and verification algorithms depend on the ability to efficiently manipulate very large BDDs. We present algorithms for manipulation of very large Binary Decision Diagrams (BDDs) on a network of workstations (NOW). A NOW provides a collection of main memories and disks which can be used effectively to create and manipulate very large BDDs. To make efficient use of memory resources of a Now, while completing execution in a reasonable amount of wall clock time, extension of breadth-first technique is used to manipulate BDDs. BDDs are partitioned such that nodes for a set of consecutive variables are assigned to the same workstation. We present experimental results to demonstrate the capability of such an approach and point towards the potential impact for manipulating very large BDDs.
Accomplishing Adaptability in Simulation Frameworks: the Bubble Approach
Authors: Andrés Díaz Pace, Mohamed Fayad, Federico Trilnik, Marcelo Campo
Venue: Proceedings of the 25th International Computer Software and Applications Conference on Invigorating Software Development (2001)

Enforcing framework adaptability is one of the key points in the process of building an object-oriented application framework. When it comes to simulation, some adaptation mechanisms to configure components on-the-fly are usually required in order to produce quality software artifacts and alleviate development effort. The paper reports an experience using a simulation multi-agent framework, initially conceived to be used in fluid flow problems. The framework architecture demonstrated during its evolution a great potential regarding to flexibility and modularity, tackling a wide range of other problems ranging from a network protocol simulation to a soccer simulation.