ppxscal/embedding_network huggingface dataset:
A Near-Optimal Packet Scheduler for QoS Networks
Authors: Dallas E. Wrege, Jorg Liebeherr
Venue:  (1996)

A packet scheduler in a quality-of-service (QoS) network should be sophisticated enough to support stringent QoS constraints at high loads, but it must also have a simple implementation so that packets can be processed at the speed of the transmission link. The Earliest-Deadline-First (EDF) scheduler is the optimal scheduler for bounded-delay services in the sense that it provides the tightest delay guarantees of any scheduler, but an implementation of EDF requires the sorting of packets, a complex operation that is not practical for high-speed networks. In this study we present the design, implementation, and analysis of the novel Rotating-Priority-Queues+ (RPQ+) scheduler that is near-optimal in the sense that it can approximate EDF with arbitrary precision. The RPQ+ scheduler uses a set of prioritized FIFO queues whose priorities are rearranged (rotated) periodically to increase the priority of waiting packets. We show that RPQ+ has the following desirable properties: its implementation requires operations independent of the number of queued packets, it can provide worst-case delay guarantees, and it is always superior to a Static-Priority (SP) scheduler. For shared-memory architectures, we show that RPQ+ can be implemented with little computational overhead. We derive expressions for the worst-case delays in an RPQ+ scheduler and demonstrate that the achievable network utilization increases with the frequency of queue rotations, approaching that of EDF in the limit. We use numerical examples, including examples based on MPEG video, to show that in realistic scenarios RPQ+ can closely approximate EDF even for infrequent queue rotations.
Application-Driven Failure Semantics of Interprocess Communication in Distributed Programs
Authors: K. Ravindran, Samuel T. Chanson, Ramakrishnam
Venue:  (1988)

Distributed systems are often modelled after the client-server paradigm where resources are managed by servers, and clients communicate with servers for operations on the resources. These client-server communications fall into two categories --- connection-oriented and connection-less, depending on whether the servers maintain state information about the clients or not. Additionally, each of the servers may itself be distributed, i.e., structured as a group of identical processes; these processes communicate with one another to manage shared resources (intra-server communications). Thus, the activities of a distributed program may be viewed as a sequence of client-server communications interspersed with intra-server communications. In this paper, we identify suitable interprocess communication (IPC) abstractions for such communications --- remote procedure calls for client-server communications and {\em application-driven shared variables} (a shared memory-like abstraction) for intra-server group communication. We specify the properties of these abstractions to handle partial failures that may occur during program execution. The issues of orphans and consistency arising due to partial failures are examined, and solution techniques application to be incorporated in the run-time system. Examples are given to illustrate the use of these bstractions as primitives for constructing distributed programs.
A Formal Specification for Procedure Calling Conventions
Authors: Mark W. Bailey, Jack W. Davidson
Venue:  (1993)

Procedure calling conventions are used to provide uniform procedure-call interfaces. Applications, such as compilers and debuggers, which generate, or process procedures at the machine-language level require an accurate description of the calling convention in use. Until now, the portion of such an application that concerns itself with the procedure call interface was implemented in an ad-hoc manner. The resulting code is complicated with details, difficult to maintain, and often incorrect. In this paper, we present a model and language, called CCL, for specifying procedure calling conventions. The language can be used to automatically generate the calling-convention specific portions of applications. It also serves as accurate documentation for a given calling convention. CCL provides a concise and natural method of specifying calling conventions that are easy to read and modify. By using a convention specification to automatically generate code, one can enhance the retargetablility of applications that make use of procedure calling conventions. Additionally, different calling conventions can easily be implemented, thereby simplifying experimentation with different call conventions to increase the efficiency of the procedure call.
New Homotopy Solution Techniques Applied to Variable Geometry Trusses
Authors: V. A Reinholtz, Layne T. Watson
Venue:  (1990)

A VGT, or Variable Geometry Truss, can be thought of as a statically determinate truss that has been modified to contain some number of variable length members. These extensible members allow the truss to vary its configuration in a controlled manner. Some of the typical applications envisioned for VGTs are booms to position equipment in space, as supports for space antennae, and as berthing devices. Recently, they have also been proposed as parallel-actuated, long-chain, high dexterity manipulators. This paper will demonstrate the use of homotopy continuation in solving the kinematics of relatively complex variable geometry trusses (VGTs), including the octahedron and the decahedron. The procedural aspects are described in detail with the help of examples. Results of the example problems are also presented.
JN: AN OPERATING SYSTEM FOR AN EMBEDDED JAVA NETWORK COMPUTER
Authors: Bruce R. Montague
Venue:  (1996)

The implementation of an embedded operating system explicitly designed to support the Java Virtual Machine on the National Semiconductor NS486 embedded PC is described. This system, the Java Nanokernel (JN), supports an Internet web server written in Java and a web Camera that can be controlled from a remote web browser. JN in principle can currently run any Java program that does not use a local display device. This paper is primarily a system overview and a summary of lessons learned.
Real-Time Garbage Collection of Actors
Authors: Douglas M. Washabaugh, Dennis G. Kafura
Venue:  (1990)

This paper shows how to perform real-time automatic garbage collection of objects possessing their own thread of control. Beyond its interest as a novel real-time problem, the relevance of automatic management and concurrent objects to real-time applications is briefly discussed. The specific model of concurrent objects used in the paper is explained. A definition of real-time garbage collection is given and an algorithm satisfying this definition is described. An analysis of the relationship between latency, memory overhead and system size shows that this approach is immediately feasible for low-performance real-time systems or multi-processor real-time systems with dedicated processor functions. Future improvements in the collector''s performance are outlined.
Response Surface Approximations for Aerodynamic Parameters in High Speed Civil Transport Optimization
Authors: Golovidov Oleg B., Mason William H., Grossman Bernard, Watson Layne T., Haftka Raphael T.
Venue:  (1997)

A procedure for generating and using polynomial approximations to the range or to the cruise drag components in terms of 29 design variables for a High Speed Civil Transport configuration design is presented. Response surface methodology is used to fit quadratic polynomials to data gathered from a series of numerical analyses of different aircraft designs. Several techniques are employed to minimize the number of required analyses and to maintain accuracy. Approximate analysis techniques are used to find regions of the design space where reasonable aircraft designs could occur and response surface models are built using higher fidelity analysis results of designs in this "reasonable" region. This is a means of using results from advanced CFD methods at the early design stage. Regression analysis and analysis of variance are used to reduce the number of polynomial terms in the response surface model functions. Optimization runs of the aircraft configuration are then carried out with the response surface models and compared to the previous optimization runs without the response surface models. It is shown that considerable reduction of the amount of numerical noise in optimization is achieved with response surface models and the convergence rate is improved. Careful attention was required to keep the accuracy of the models at an acceptable level.
A Measurement Study of Two Local Area Network Data Link Level Protocols
Authors: Benjamin L Barnett,  III, Michael K. Molloy
Venue:  (1988)

Two protocols for the data link level of Local Area Networks, the original Ethernet protocol and the EnetII protocol, are compared. The two protocols were implemented on a testbed network. A variety of performance measurement experiments were run for each protocol, and information on throughput and packet delay was collected. We have investigated the performance of the Ethernet and Enet II protocols under varying load conditions. The protocols were found to have similar throughput and delay characteristics under normal network conditions, while Enet II achieved higher throughput and greater stability under extreme overload conditions. The predicted delay advantage for Enet II was not observed in these measurements due to implementation compromises, but Enet II was observed to achieve its goal of greatly reducing the variance of the packet queueing delay.
Definite Clause Translation Grammars \& the Logical Specification of Data Types as Unambiguous Context Free Grammars
Authors: Harvey Abramson
Venue:  (1984)

Data types may be considered as unambiguous context free grammars. The elements of such a data type are the derivation trees of sentences generated by the grammars. Furthermore, the generators and recognizers of non-terminals specified by such grammars provide the composition and decomposition operators which can be used to define functions or predicates over such data types. We present a modification of our Definite Clause Translation Grammars (Abramson 1984) which is used to logically specify data types as unambiguous context free grammars. For example, here is a grammatical specification of binary trees: \begin{center} string.$ \\ "(" , left :tree, " ,", right :tree, " )".$ \end{center} The decomposition ``operators'''', left, right, and (implicitly) string, are semantic attributes generated by the compiler which translates these grammar rules to Prolog clauses; these operators, together with the parser for $tree$s, and the predicates $leaf$ and $branch$, can be used to construct more complex predicates over the data type $tree$. We show how such grammars can be used to impose a typing system on logic programs; and indicate how such grammars can be used to implement Kaviar, a functional programming language based on data types as context tree grammars.
Event-based Distributed Workflow Execution with EVE
Authors: Andreas Geppert, Dimitrios Tombros
Venue:  (1996)

In event-driven workflow execution, events and event-condition-action rules are the fundamental metaphors for defining and enforcing workflow logic. Processing entities enact workflows by reacting to and generating new events. The foundation on events also eases the integration of processing entities into coherent systems. In this paper, we present an event engine, called EVE, implementing event-driven execution of distributed workflows. Its functionality includes event registration, detection and management, as well as event notification to distributed, autonomous, reactive software components which represent workflow processing entities. EVE also maintains a history of all event occurrences in the system used for the monitoring and analysis of executing workflows. We describe the distributed, multi-server, multi- client architecture of EVE and illustrate its usage for workflow execution.
Atlas: A Case Study in Building a Web-Based Learning Environment Using Aspect-oriented Programming
Authors: Mik A. Kersten, Gail C. Murphy
Venue:  (1999)

The Advanced Teaching and Learning Academic Server (Atlas) is a software system that supports web-based learning. Students can register for courses, and can navigate through personalized views of course material. Atlas has been built according to Sun Microsystem''s Java (TM) Servlet specification using Xerox PARC''s aspect-oriented programming support called AspectJ (TM). Since aspect-oriented programming is still in its infancy, little experience with employing this paradigm is currently available. In this paper, we start filling this gap by describing the aspects we used in Atlas and by discussing the effect of aspects on our object-oriented development practices. We describe some rules and policies that we employed to achieve our goals of maintainability and modifiability, and introduce a straightforward notation to express the design of aspects. Although we faced some small hurdles along the way, this combination of technology helped us build a fast, well-structured system in a reasonable amount of time.
Performance Prediction of Parallel Self Consistent Field Computation
Authors: J. Papay, T. J. Atherton, M. J. Zemerly, G. R. Nudd
Venue:  (1996)

This paper presents a methodology for performance prediction of parallel algorithms and illustrates its use on a large scale computational chemistry application. The performance prediction uses a component time characterisation technique which splits up the sequential code into computational components and measures the time for each of them. The parallel algorithm is built from these components by adding communication routines. A "Processor Activity Graph" (PAG) providing a graphical representation of the parallel algorithm runtime behaviour is used for predicting the execution time. For a case study a Self Consistent Field (SCF) computation has been selected which forms the basis of many computational chemistry packages [4,5]. The performance model of SCF computation has been built and the predictions have been compared with the results of measurements. The measurements have been provided on a mesh connected distributed memory parallel computer (128 T800 Parsytec SuperCluster). The prediction error is less than 10 percent. Performance optimisation of the application has been achieved by reducing the communication overhead and changing the data representation. This paper introduces a new model of computation that employs the tools of molecular biology whose in vitro implementation is far more error-resistant than extant proposals. We describe an abstraction of the model which lends itself to natural algorithmic description, particularly for problems in the complexity class NP. In addition we describe a number of linear-time algorithms within our model, particularly for NP-complete problems. We describe an in vitro realisation of the model and conclude with a discussion of future work.
PIPS--A general purpose Parallel Image Processing System
Authors: Michael Nolle, Gerald Schreiber, Hanns Schulz-Mirbach
Venue:  (1994)

In this paper we discuss general requirements for parallel implementations of image processing algorithms. Of special importance are the communication demands in the parallel system which are determined by the algorithm under consideration. These communication demands are decisive for determining the best way to distribute the image data to the network processors. Analysing these factors for some typical image processing algorithms reveals that it is difficult to find a fixed network structure which meets all the demands equally well. A possibility to cope with these problems is to embed different topologies into a fixed network structure. The mentioned factors were guidelines for the design of the general purpose Parallel Image Processing System PIPS. We describe the structure of this software package and elucidate for some selected topics the implementation details. Experimental results from an implementation on a multiprocessor system are presented.
Using Deficiency Measure For Tiebreaking the Minimum Degree Algorithm
Authors: Ian A. Cavers
Venue:  (1989)

The minimum degree algorithm is known as an effective scheme for identifying a fill reduced ordering for symmetric, positive definite, sparse linear systems. Although the original algorithm has been enhanced to improve the efficiency of its implementation, ties between minimum degree elimination candidates are still arbitrarily broken. For many systems, the fill levels of orderings produced by the minimum degree algorithm are very sensitive to the precise manner in which these ties are resolved. This paper introduces several tiebreaking schemes for the minimum degree algorithm. Emphasis is placed upon a tiebreaking strategy based on the deficiency of minimum degree elimination candidates, which can consistently identify low fill orderings for a wide spectrum of test problems. The tiebreaking strategies are integrated into a quotient graph form of the minimum degree algorithm with uneliminated supernodes. Implementations of the enhanced forms of the algorithm are tested on a wide variety of sparse systems to investigate the potential of the tiebreaking strategies.
Automatically Parallelizing Serial Programs Using Commutativity Analysis
Authors: Martin Rinard, Pedro Diniz
Venue:  (1995)

This paper introduces a new analysis technique, commutativity analysis, for automatically parallelizing programs written in a sequential, imperative programming language. Existing parallelizing compilers preserve the data dependences of the original serial program. They analyze the program at the level of individual reads and writes to single words of memory to generate parallel code that preserves the relative order of reads and writes to the same word. Commutativity analysis, on the other hand, aggregates both data and computation into larger grain units. It then analyzes the computation at this granularity to discover when pieces of the computation commute (i.e. generate the same result regardless of the order in which they execute). If all of the operations required to perform a given computation commute, the compiler can automatically generate parallel code. While the resulting parallel program may violate the data dependences of the original serial program, it is still guaranteed to generate the same result. This paper presents commutativity analysis and shows how to exploit the extracted information to automatically generate parallel code.
Algebraic Database Migration to Object Technology
Authors: Andreas Behm, Andreas Geppert, Klaus R. Dittrich
Venue:  (1999)

Relational database systems represent the current standard technology for implementing database applications. Now that the object-oriented paradigm becomes more and more mature in all phases of the software engineering process, object-oriented DBMS are seriously considered for the seamless integration of object-oriented applications and data persistence. When reengineering existing applications or constructing new ones on top of relational databases, a large semantic gap between the new object model and the legacy database''s model must still be bridged. We propose database migration to resolve this mismatch: the relational schema is transformed into an object-oriented one and the relational data is migrated to an object-oriented database. Existing approaches for migration do not exploit the full potential of the object-oriented paradigm so that the resulting object-oriented schema still "looks rather relational" and retains the drawbacks and weaknesses of the relational schema. We propose a redesign environment which allows to transform relational schemas into adequate object-oriented ones. Schemas and transformation rules are expressed in terms of a new data model, called semi object types (SOT). We also propose a formal foundation for SOT and transformation rules. This formalization makes it possible to automatically generate the input of the data migration process.
NPSI adaptive synchronization algorithms for PDES
Authors: Paul F. Reynolds,  Jr.
Venue:  (1994)

Research in parallel discrete event simulation indicates that neither purely conservative nor purely optimistic synchronization algorithms will perform well consistently. We survey several new approaches that attempt to improve performance by limiting optimistic execution. In most of these, the criterion for limiting optimism is static or based on local information, which conflicts with the dynamic nature of discrete event simulations. We contend that an adaptive approach based on low cost near-perfect system state information is the most likely to yield a consistently efficient synchronization algorithm. We suggest a framework by which NPSI (near-perfect state information) adaptive protocols could be designed and describe the first such protocol - Elastic Time Algorithm. We present performance results from an implementation of this algorithm which show that adaptive protocols based on the use of NPSI are promising. In particular, we show that NPSI adaptive protocols have the capacity to be more efficient than Time Warp in both time and space. We identify major issues in the design and usability of NPSI protocols and discuss ongoing research.
CHITRA94: A Tool to Dynamically Charaterize Ensembles of Traces for Input Data Modeling and Output Analsis
Authors: Abrams Marc, Batonbacal Alan, Ribler Randy, Vazirani Devendra
Venue:  (1994)

CHITRA94 is the third generation of a comprehensive system to visualize, transform, statistically analyze, and model ensembles of trace data and validate the resultant models. The tool is useful for deriving input data models from trace data as well as for analysis of trace data output by a simulation. The tool uses an stochastic (possibly no-Markovian) process as its fundamental modeling component. The tool is unique in several respects. First, it focuses on the dynamic characterization of systems. Consequently it includes tests for homogeneity of ensembles, stationarity of individual traces, and the ability to partition ensembles into transient and stationary pieces. Second, CHITRA94 is a scalable performance tool: its methods are designed to work with an arbitrary number of traces in an ensemble so that a user can examine the variability of system behaviors across different traces (representing different observation periods, different system configurations, etc.). To analyze multiple traces, the user can either (1) map the traces to a model that characterizes the dynamic behavior or (2) use a novel visualization, the mass evolution graph, that shows the probability mass distribution evolution of one or more traces. A mass evolution graph is easily constructed from trace data, and the derivative of the paths it contains yield an estimate of probability mass as a function of time. Third, it analyzes categorical, not just numerical, time series data. Categorical data arises naturally in many computer and communication system modeling problems. Fourth, it includes a library of transforms that reduce the state space of the stochastic process generated. Fifth, CHITRA94 is implemented as a user extensible collection of small programs, organized as a library, which allows the user to write new library modules that use existing modules to automate analysis procedures. Instead, CHITRA94 may be invoked from command line, under a GUI, or integrated with another tool (e.g., a simulation model development or CASE tool). The use of CHITRA94 is illustrated on a variety of trace data, and the extensibility is illustrated on the problem of partitioning an ensemble of 60 traces of compressed entertainment video into mutually exclusive, exhaustive, and homogeneous subsets from which a hierarchical workload model is derived.