Efficient reachability testing of asynchronous message-passing programs

Recent interests on XML, Semantic Web, and Web ontology, among other topics, have sparked a renewed interest on graph-structured databases. A fundamental query on graphs is the reachability test of nodes. This thesis includes a survey on various indexes to optimize reachability tests. The focus of this thesis is 2-hop labeling indexing method which was recently proposed to index large collections of XML and/or graphs for efficient reachability tests. In particular, we note that there has been few works on 2-hop labeling in dynamic setting where the graph is frequently updated. This is compounded by the fact that data may change over time. In response to these, this thesis studies the incremental maintenance of 2-hop labeling. We analyze the main reason for the inefficiency of updates of existing 2-hop labels. Based on our analysis, we propose node-separation property that leads to efficient incremental maintenance. Subsequently, we present novel incremental maintenance algorithms for 2-hop labels. Wepropose three updatable 2-hop labelings, hybrids of 2-hop labeling that satisfies node-separation property. The proposed 2-hop labeling is derived from graph connectivity, as opposed to SET COVER which is used by all previous work. Our experimental evaluation illustrates the space efficiency and update performance of various kinds of 2-hop labeling. Our results show that the incremental maintenance algorithm can be two orders of magnitude faster than previous methods and the size of our 2-hop labeling can be comparable to the existing 2-hop labeling.

We propose weakening the definition of progress to a branching-time operator, making it more amenable to compositional proof and simplifying the predicates needed to reason about highly asynchronous programs. The new progress operator (“achieves”) coincides with the “leads-to” operator on all “observable” progress properties (those where the target predicate is stable) and satisfies the same composition properties as leads-to, including the PSP theorem. The advantage of achievement lies in its compositionality: a program inherits all achievement properties of its “decoupled components”. (For example, a dataflow network inherits achievement properties from each of its processes.) The compositionality of achievement captures, in a UNITY-like logic, the well-known operational trick of reasoning about an asynchronous program by considering only certain well-behaved executions.KeywordsComposition PropertyProgress PropertyFIFO ChannelTarget PredicateCompositional ProofThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

JavaScript programmers make extensive use of event-driven programming to help build responsive web applications. However, standard approaches to sequencing events are messy, and often lead to code that is difficult to understand and maintain. We have found that arrows, a generalization of monads, are an elegant solution to this problem. Arrows allow us to easily write asynchronous programs in small, modular units of code, and flexibly compose them in many different ways, while nicely abstracting the details of asynchronous program composition. In this paper, we present Arrowlets, a new JavaScript library that offers arrows to the everyday JavaScript programmer. We show how to use Arrowlets to construct a variety of state machines, including state machines that branch and loop. We also demonstrate how Arrowlets separate computation from composition with examples such as a drag-and-drop handler and a bubblesort animation.

: This final report describes results of the Phase I SBIR research effort to develop new software testing techniques capable of satisfying the demands of distributed real-time software environments. Traditional software testing techniques are inadequate for distribute systems due to such complicating factors as non-deterministic execution, real-time timing constraints, task interaction event sequencing, race conditions, etc. During the course of the Phase I-effort, OTI investigate a wide variety of candidate technique. For each technique, OTI evaluated the feasibility and defined a research and development approach for the technique and required supporting technologies. Detailed comparison-of the attributes of each technique gives the following prioritization of techniques: Deterministic Execution Testing, Timing Analysis, Control Flow Testing, Dependency Analysis, Network Communication Testing, Data Flow Analysis, Problem Tracking Facility, Mutation Analysis, Static Concurrency Testing. OTI's research approach was based on developing new functionality on top of an existing software testing environment to construct the Environment for Test and Analysis of Distributed Software (ETADS). Distributed software testing, Software testing environment, Control flow analysis, Data flow analysis, Timing analysis, Software instrumentation, Non- determinism, Deterministic replay.

The aim of this study was to estimate the incremental budget impact (IBI) of a rapid diagnostic test to detect G6PDd in male patients infected with Plasmodium vivax in the Brazilian Amazon, as compared with the routine protocol recommended in Brazil which does not include G6PDd testing. The budget impact analysis was performed from the perspective of the Brazilian health system, in the Brazilian Amazon for the years 2013, 2014 and 2015. The analysis used a decision model to compare two scenarios: the first consisting of the routine recommended in Brazil which does not include prior diagnosis of dG6PD, and the second based on the use of RDT CareStart™ G6PD (CS-G6PD) in all male subjects diagnosed with vivax malaria. The expected implementation of the diagnostic test was 30% in the first year, 70% the second year and 100% in the third year. The analysis identified negative IBIs which were progressively smaller in the 3 years evaluated. The sensitivity analysis showed that the uncertainties associated with the analytical model did not significantly affect the results. A strategy based on the use of CS-G6PD would result in better use of public resources in the Brazilian Amazon.

In this paper, we present a policy for optimally balancing computing resources in a networked computing environment. In particular, we examine how to balance the computation time between tasks in a virtualized pipeline of distinct resources such as network control elements and servers. We consider a paradigm with limited resources to be divided among pipeline stages for maximum efficiency. This strategy has general applications across a range of hierarchical levels within a data center, from the classical processor pipeline to cloud-level computation tasks. Furthermore, the final control strategy can be simply implemented using a simple switching policy, establishing its suitability for high-speed applications. We show a policy iteration technique to determine and implement the this switching policy. Numerical results are presented as a demonstration of the policy iteration convergence, resulting in significant improvements from more basic control methods. Finally, we discuss potential directions for future work in efficient testing, implementation, and near-optimal approximations to our optimal control policy.

Message-passing programs are difficult to test because of their non-deterministic behavior. One approach, called non-deterministic testing, involves executing a message-passing program with the same input many times in hope that faults would be exposed by one of these executions. Non-deterministic testing has been widely used in practice, but unfortunately, in an ad-hoc manner. In this paper, we present a novel framework for non-deterministic testing of message-passing programs. The framework uses a coverage criterion to guide the testing process. During each test run, the sequence of send and receive events that are executed is recorded in an execution trace. After each test run, the trace is analyzed to identify race conditions, which are used to derive coverage elements that have not been covered yet. Then, random delays are inserted at a chosen set of program locations in order to increase the chance of covering the uncovered elements in the next test run. This framework provides a heuristic condition that can be used to decide when to stop testing. The condition is easy to compute and its satisfaction signals that the coverage criterion has likely been satisfied. This framework can be automated at the source code level and allows one to obtain a measure of test coverage at the end of the testing process. We describe a prototype tool and report some empirical results that demonstrate the effectiveness of our framework.

In these notes, we give an overview of the join calculus, its semantics, and its equational theory. The join calculus is a language that models distributed and mobile programming. It is characterized by an explicit notion of locality, a strict adherence to local synchronization, and a direct embedding of the ML programming language. The join calculus is used as the basis for several distributed languages and implementations, such as JoCaml and functional nets.Local synchronization means that messages always travel to a set destination, and can interact only after they reach that destination; this is required for an efficient implementation. Specifically, the join calculus uses ML’s function bindings and pattern-matching on messages to program these synchronizations in a declarative manner.Formally, the language owes much to concurrency theory, which provides a strong basis for stating and proving the properties of asynchronous programs. Because of several remarkable identities, the theory of process equivalences admits simplifications when applied to the join calculus. We prove several of these identities, and argue that equivalences for the join calculus can be rationally organized into a five-tiered hierarchy, with some trade-off between expressiveness and proof techniques.We describe the mobility extensions of the core calculus, which allow the programming of agent creation and migration. We briefly present how the calculus has been extended to model distributed failures on the one hand, and cryptographic protocols on the other.KeywordsMobile AgentOperational SemanticParallel CompositionProof TechniqueCouple SimulationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The stream programming paradigm aims to expose coarsegrained parallelism in applications that must process continuous sequences of events.The appeal of stream programming comes from its conceptual simplicity.A program is a collection of independent filters which communicate by the means of uni-directional data channels.This model lends itself naturally to concurrent and efficient implementations on modern multiprocessors.As the output behavior of filters is determined by the state of their input channels, stream programs have fewer opportunities for the errors (such as data races and deadlocks) that plague shared memory concurrent programming.This paper introduces STREAMFLEX, an extension to Java which marries streams with objects and thus enables to combine, in the same Java virtual machine, stream processing code with traditional object-oriented components.STREAMFLEX targets high-throughput low-latency applications with stringent quality-of-service requirements.To achieve these goals, it must, at the same time, extend and restrict Java.To allow for program optimization and provide latency guarantees, the STREAMFLEX compiler restricts Java by imposing a stricter typing discipline on filters.On the other hand, STREAMFLEX extends the Java virtual machine with real-time capabilities, transactional memory and type-safe region-based allocation.The result is a rich and expressive language that can be implemented efficiently.

The stream programming paradigm aims to expose coarse-grained parallelism inapplications that must process continuous sequences of events. The appeal ofstream programming comes from its conceptual simplicity. A program is acollection of independent filters which communicate by the means ofuni-directional data channels. This model lends itself naturally toconcurrent and efficient implementations on modern multiprocessors. As theoutput behavior of filters is determined by the state of their inputchannels, stream programs have fewer opportunities for the errors (such asdata races and deadlocks) that plague shared memory concurrent programming. This paper introduces S<scp>tream</scp>F<scp>lex</scp>, an extension to Java which marries streams with objects and thus enables to combine, in the same Java virtual machine, stream processing code with traditional object-oriented components. S<scp>tream</scp>F<scp>lex</scp> targets high-throughput low-latency applications with stringent quality-of-service requirements. To achieve these goals, it must, at the same time, extend and restrict Java. To allow for program optimization and provide latency guarantees, the S<scp>tream</scp>F<scp>lex</scp> compiler restricts Java by imposing a stricter typing discipline on filters. On the other hand, S<scp>tream</scp>F<scp>lex</scp> extends the Java virtual machine with real-time capabilities, transactional memory and type-safe region-based allocation. The result is a rich and expressive language that can be implemented efficiently.