Search

We studied two forms of dyad practice, compared to individual practice, to determine whether and how practice with a partner impacts performance and learning of a balance task, as well as learners’ subjective perceptions of the practice experience. Participants were assigned to practice alone or in pairs. Partners either alternated turns practicing and observing one another, or they practiced and observed one another concurrently. Concurrent action observation impacted online action execution such that partners tended to show coupled movements, and it was perceived as more interfering than practicing in alternation. These differences did not impact error during practice. While dyad practice was associated with higher ratings of effort than individual practice, all groups improved and showed similar immediate and delayed retention irrespective of whether practice was alone or in pairs. These data provide evidence that a partner’s concurrent practice influences one’s own performance, but not to the detriment (or benefit) of learning. Thus, both alternating and concurrent forms of dyad practice are viable means of enhancing the efficiency, albeit not necessarily the effectiveness, of motor learning. [ABSTRACT FROM AUTHOR]

Modern architectures rely on memory fences to prevent undesired weakenings of memory consistency. As the fences' semantics may be subtle, the automation of their placement is highly desirable. But precise methods for restoring consistency do not scale to deployed systems' code. We choose to trade some precision for genuine scalability: our technique is suitable for large code bases. We implement it in our new musketeer tool and report experiments on more than 700 executables from packages found in Debian GNU/Linux 7.1, including memcached with about 10,000 LoC. [ABSTRACT FROM AUTHOR]

In this paper we present a brief overview of a representative fragment of the theory of regions. Regions are a powerful tool for the synthesis of concurrent systems from a behavioural specification. To demonstrate the robustness of region based synthesis we survey some of the existing results for extensions of place/transition nets. We relate in particular to the general approach founded on τ -nets and τ -regions. A new extension of region theory to the case of Petri nets with whole-place operations is presented. [ABSTRACT FROM AUTHOR]

We present a new abstract interpretation based approach for automatically verifying concurrent programs running on relaxed memory models. Our approach is based on three key insights: (i) Although the behaviors of relaxed memory models (e.g., TSO and PSO) are naturally captured by store buffers, directly using such encodings substantially decreases the accuracy of program analysis due to shift operations on buffer contents. The scalability and accuracy of program analysis can be greatly improved by eliminating the expensive shifting of store buffer contents, and we present a new abstraction of the memory model that accomplishes this goal. (ii) The precision of the analysis can be further improved by an encoding of store buffer sizes using leveraged knowledge of the abstract interpretation domain. (iii) A novel source-to-source transformation that realizes the above two techniques makes it possible to use of state-of-the-art analyzers directly under sequential consistency (SC): given a program P and a relaxed memory model M , it produces a new program P M where the behaviors of P running on M are over-approximated by the behavior of P M running on SC. We implemented our approach and evaluated it on a set of finite and infinite-state concurrent algorithms under two memory models: Intel׳s x86 TSO and PSO. Experimental results indicate that our technique achieves better precision and efficiency than prior work: we can automatically verify algorithms with fewer fences, faster and with lower memory consumption. [ABSTRACT FROM AUTHOR]

We present a model checking-based method for verifying list-based concurrent set data structures. Concurrent data structures are notorious for being hard to get right and thus, their verification has received significant attention from the verification community. These data structures are unbounded in two dimensions: the list size is unbounded and an unbounded number of threads access them. Thus, their model checking requires abstraction to a model bounded in both the dimensions. We first show how the unbounded number of threads can be model checked by reduction to a finite model, while assuming a bounded number of list nodes. In particular, we leverage the CMP (CoMPositional) method which abstracts the unbounded threads by keeping one thread as is (concrete) and abstracting all the other threads to a single environment thread. Next, the method proceeds as a series of iterations where in each iteration the abstraction is model checked and, if a spurious counterexample is observed, refined. This is accomplished by the user by inspecting the returned counterexamples. If the user determines the returned counterexample to be spurious, she adds constraints to the abstraction in the form of lemmas to refine it. Upon addition, these lemmas are also verified for correctness as part of the CMP method. Thus, since these lemmas are verified as well, we show how some of the lemmas required for refinement of this abstract model can be mined automatically using an assertion mining tool, Daikon. Next, we show how the CMP method approach can be extended to the list dimension as well, to fully verify the data structures in both the dimensions. While it is possible to show correctness of these data structures for an unbounded number of threads by keeping one concrete thread and abstracting others, this is not directly possible in the list dimension as the nodes pointed to by the threads change during list traversal. Our method addresses this challenge by constructing an abstraction for which the concrete nodes, i.e., the nodes pointed to by the threads, can change as the thread pointers move with program execution. Further, our method also allows for refinement of this abstraction to prove properties of interest. We show the soundness of our method and establish its utility by model checking challenging concurrent list-based data structure examples. [ABSTRACT FROM AUTHOR]

Concurrent computation has been with us for over 50 years, and has become essential today. Concurrency paradigms affect the way we think about parallelism, the programs we try to write, the algorithms we choose, the performance we achieve, the errors we make, and the support mechanisms we need. The paradigms are not equivalent. Although each paradigm can usually be simulated in environments designed for a different paradigm, such a 'Turing machine style' proof of computational equivalency does not establish equivalency in terms of the effort required to program solutions, the proclivity for solutions to be error-prone, or the comparable effectiveness of solutions. Two classic concurrency paradigms are reviewed. A third (not so widely recognized) concurrency paradigm is then discussed. [ABSTRACT FROM AUTHOR]

Unified Modeling Language (UML) activity diagrams are widely used to model concurrent interaction among multiple objects. In this paper, we propose a transformation-based approach to generating scenario-oriented test cases for applications modeled by UML activity diagrams. Using a set of transformation rules, the proposed approach first transforms a UML activity diagram specification into an intermediate representation, from which it then constructs test scenarios with respect to the given concurrency coverage criteria. The approach then finally derives a set of test cases for the constructed test scenarios. The approach resolves the difficulties associated with fork and join concurrency in the UML activity diagram and enables control over the number of the resulting test cases. We further implemented a tool to automate the proposed approach and studied its feasibility and effectiveness using a case study. Experimental results show that the approach can generate test cases on demand to satisfy a given concurrency coverage criterion and can detect up to 76.5% of seeded faults when a weak coverage criterion is used. With the approach, testers can not only schedule the software test process earlier, but can also better allocate the testing resources for testing concurrent applications. Copyright © 2015 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Testing of concurrent software written in programming languages like Java and C/C++ is a highly challenging task owing to the many possible interactions among threads. A simple, cheap, and effective approach that addresses this challenge is testing with noise injection, which influences the scheduling so that different interleavings of concurrent actions are witnessed. In this paper, multiple results achieved recently in the area of noise-injection-based testing by the authors are presented in a unified and extended way. In particular, various concurrency coverage metrics are presented first. Then, multiple heuristics for solving the noise placement problem (i.e. where and when to generate noise) as well as the noise seeding problem (i.e. how to generate the noise) are introduced and experimentally evaluated. In addition, several new heuristics are proposed and included into the evaluation too. Recommendations on how to set up noise-based testing for particular scenarios are then given. Finally, a novel use of the genetic algorithm for finding suitable combinations of the many parameters of tests and noise techniques is presented. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

SUMMARY General purpose computation on graphics processing unit (GPU) is rapidly entering into various scientific and engineering fields. Many applications are being ported onto GPUs for better performance. Various optimizations, frameworks, and tools are being developed for effective programming of GPU. As part of communication and computation optimizations for GPUs, this paper proposes and implements an optimization method called as kernel coalesce that further enhances GPU performance and also optimizes CPU to GPU communication time. With kernel coalesce methods, proposed in this paper, the kernel launch overheads are reduced by coalescing the concurrent kernels and data transfers are reduced incase of intermediate data generated and used among kernels. Computation optimization on a device (GPU) is performed by optimizing the number of blocks and threads launched by tuning it to the architecture. Block level kernel coalesce method resulted in prominent performance improvement on a device without the support for concurrent kernels. Thread level kernel coalesce method is better than block level kernel coalesce method when the design of a grid structure (i.e., number of blocks and threads) is not optimal to the device architecture that leads to underutilization of the device resources. Both the methods perform similar when the number of threads per block is approximately the same in different kernels, and the total number of threads across blocks fills the streaming multiprocessor (SM) capacity of the device. Thread multi-clock cycle coalesce method can be chosen if the programmer wants to coalesce more than two concurrent kernels that together or individually exceed the thread capacity of the device. If the kernels have light weight thread computations, multi clock cycle kernel coalesce method gives better performance than thread and block level kernel coalesce methods. If the kernels to be coalesced are a combination of compute intensive and memory intensive kernels, warp interleaving gives higher device occupancy and improves the performance. Multi clock cycle kernel coalesce method for micro-benchmark1 considered in this paper resulted in 10-40% and 80-92% improvement compared with separate kernel launch, without and with shared input and intermediate data among the kernels, respectively, on a Fermi architecture device, that is, GTX 470. A nearest neighbor (NN) kernel from Rodinia benchmark is coalesced to itself using thread level kernel coalesce method and warp interleaving giving 131.9% and 152.3% improvement compared with separate kernel launch and 39.5% and 36.8% improvement compared with block level kernel coalesce method, respectively.Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Simpson and Harris have described multi-slot algorithms implementing a single-place buffer, each operating without explicit hardware synchronisation mechanisms. Conventional refinement and proof techniques have explained that these algorithms work, but do not give convincing descriptions of how they work. An unconventional refinement process starting from the classic single-variable buffer, using both data and atomicity refinement and drawing information from unsuccessful steps, derives each algorithm. The logic used is RGSep, a marriage of rely/guarantee and concurrent separation logic. Extensive detailed verifications are described. The result is an explanation of how the algorithms work and some pointers to how such algorithms might be devised. [ABSTRACT FROM AUTHOR]

We present a novel framework for automatic inference of efficient synchronization in concurrent programs, a task known to be difficult and error-prone when done manually. Our framework is based on abstract interpretation and can infer synchronization for infinite state programs. Given a program, a specification, and an abstraction, we infer synchronization that avoids all (abstract) interleavings that may violate the specification, but permits as many valid interleavings as possible. Combined with abstraction refinement, our framework can be viewed as a new approach for verification where both the program and the abstraction can be modified on-the-fly during the verification process. The ability to modify the program, and not only the abstraction, allows us to remove program interleavings not only when they are known to be invalid, but also when they cannot be verified using the given abstraction. We implemented a prototype of our approach using numerical abstractions and applied it to verify several example programs. [ABSTRACT FROM AUTHOR]

Mazurkiewicz traces are a widely used model for describing the languages of concurrent systems computations. The causal structure of atomic actions occurring in a process modeled as a trace generates a partial order. Hasse diagrams of such order are very common structures used for presentation and investigation in the concurrency theory, especially from the behavioural perspective. We present effective algorithms for Hasse diagrams construction and transformation. Later on, we use them for enumeration of all linearisations of the partial order that represents a concurrent process. Additionally, we attach the flexible visual implementation of all considered algorithms. [ABSTRACT FROM AUTHOR]

Recently, vehicular sensor networks (VSNs) have emerged as a new intelligent transport networking paradigm in the Internet of Things. By sensing, collecting, and delivering traffic-related information, VSNs can significantly improve both driving experience and traffic flow control, especially in constrained urban environments. Latest technological advances enable vehicular devices to be equipped with multiple wireless interfaces, which can support cooperative communications for concurrent multipath transfer (CMT) in VSNs. However, path heterogeneity and vehicle mobilitycause CMT not to achieve the same high transport efficiency recorded in wired nonmobile network environments. This paper proposes a novel vehicular network-based CMT solution (VN-CMT) to address the above issues and improve data delivery efficiency. VN-CMT is based on a CMT disorder analytic model which can effectively and accurately evaluate the degree of out-of-order data. Based on this proposed model, a series of mechanisms are introduced as follows: (1) a packet disorder-reducing retransmission policy to reduce retransmission delay; (2) a path group selection algorithm to find the best path set for data multipath concurrent transfer; and (3) a data scheduling mechanism to distribute data according to each path's capacity. Simulation results show how VN-CMT improves data delivery efficiency in comparison with an existing state-of-the-art solution. [ABSTRACT FROM AUTHOR]

Dynamical concurrent execution makes it possible to adapt programs for their execution on computing environments with parallel architecture. In the paper, a formal model of dynamical concurrent execution of programs written in functional style is presented. The model is proven to possess a feature that guarantees correctness of concurrent execution. [ABSTRACT FROM AUTHOR]

A concurrency control mechanism for a networked virtual environment is a key element in many collaborative computer-aided design applications. However, conventional object-based locking mechanisms restrict the behaviors of nonowners, and an attribute-based locking mechanism may produce another problem called task-surprise, which disturbs users' collaboration. In this paper, we propose a hybrid concurrency control mechanism that reduces restrictions of nonowners' behaviors and task-surprises in a networked virtual environment. The proposed method consists of two concurrency control approaches: task-based concurrency control and personal work-spaces. The task-based concurrency control approach allows nonowners to do some tasks if they do not conflict with the tasks of the owner of the shared object. The personal workspaces approach provides an independent workspace where a user can manipulate copies of the shared objects. The proposed method was applied to a collaborative level design for a large-scale online game as a case study. We evaluated its performance by experiments and user studies to check acceptance and usability of the proposed method. [ABSTRACT FROM AUTHOR]

Abstract: A future is a well-known programming construct used to introduce concurrency into sequential programs. Computations annotated as futures are executed asynchronously and run concurrently with their continuations. Typically, futures are not transparent annotations: a program with futures need not produce the same result as the sequential program from which it was derived. Safe futures guarantee that a future-annotated program produces the same result as its sequential counterpart. The safety property is trivially satisfied in languages without side-effects or exceptions. In the presence of mutable references and language abstractions, such as exceptions, which permit the expression of non-local control-flow, ensuring safety requires that the future-annotated program adhere to control and data dependences imposed by the program’s sequential counterpart. In this paper, we present a formulation of safe futures for a higher-order functional language with first-class references and exceptions. Safety can be guaranteed at runtime by blocking a continuation from performing a potentially unsafe action before its futures have completed. To enable greater concurrency, we develop a static analysis and instrumentation and formalize the runtime behavior for instrumented programs that allows a continuation to proceed before its futures complete, as long as its actions are determined to be safe. A continuation’s action is safe if it is not control or data dependent on actions that may subsequently be performed by its futures. [Copyright &y& Elsevier]

Strategic ability updating relates to establishing some required properties, which can be expressed by strategic abilities, in a multicomponent reactive system. We model such a reactive system as a concurrent game structure (CGS), which is the semantic model of Alternating-time Temporal Logic (ATL). Then, we propose coalitional commitment as a tool for achieving the required strategic ability updating. Intuitively, a coalitional commitment can extend the state space of a CGS by a context function and then delete some transitions by a coalitional normative system (CNS). We propose coordinated ATL (co-ATL) for reasoning about strategic abilities in the structures obtained from a CGS by implementing a CNS. The model-checking problem for co-ATL is proved to be PTIME-complete, just like that of ATL, and is thus tractable. Then, we characterize the limitation of coalitional commitment power by identifying the set of co-ATL formulas whose satisfaction cannot be established and the set of co-ATL formulas whose satisfaction cannot be avoided. Afterward, we show that the effectiveness problem, feasibility problem, and synthesis problem for coalitional commitment are PTIME-complete, NP-complete, and FNP-complete, respectively. Finally, we treat the coalitional commitment synthesis problem as an extended planning problem and present an algorithm based on the planning as model checking paradigm. Our work can be seen as an improvement for both social law research and planning via model checking research. [ABSTRACT FROM AUTHOR]

Compositional theories are crucial when designing large and complex systems from smaller components. In this work we propose such a theory for synchronous concurrent systems. Our approach follows so-called interface theories, which use game-theoretic interpretations of composition and refinement. These are appropriate for systems with distinct inputs and outputs, and explicit conditions on inputs that must be enforced during composition. Our interfaces model systems that execute in an infinite sequence of synchronous rounds. At each round, a contract must be satisfied. The contract is simply a relation specifying the set of valid input/output pairs. Interfaces can be composed by parallel, serial or feedback composition. A refinement relation between interfaces is defined, and shown to have two main properties: (1) it is preserved by composition, and (2) it is equivalent to substitutability, namely, the ability to replace an interface by another one in any context. Shared refinement and abstraction operators, corresponding to greatest lower and least upper bounds with respect to refinement, are also defined. Input-complete interfaces, that impose no restrictions on inputs, and deterministic interfaces, that produce a unique output for any legal input, are discussed as special cases, and an interesting duality between the two classes is exposed. A number of illustrative examples are provided, as well as algorithms to compute compositions, check refinement, and so on, for finite-state interfaces. [ABSTRACT FROM AUTHOR]

The Block Conjugate Gradient algorithm (Block-CG) was developed to solve sparse linear systems of equations that have multiple right-hand sides. We have adapted it for use in heterogeneous, geographically distributed, parallel architectures. Once the main operations of the Block-CG (Tasks) have been collected into smaller groups (subjobs), each subjob is matched by the middleware MJMS (MPI Jobs Management System) with a suitable resource selected among those which are available. Moreover, within each subjob, concurrency is introduced at two different levels and with two different granularities: the coarse-grained parallelism to perform independent tasks and the fine-grained parallelism within the execution of a task. We refer to this algorithm as to multi-grained distributed implementation of the parallel Block-CG. We compare the performance of a parallel implementation with the one of the distributed implementation running on a variety of Grid computing environments. The middleware MJMS-developed by some of the authors and built on top of Globus Toolkit and Condor-G-was used for co-allocation, synchronization, scheduling and resource selection. Copyright © 2010 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Abstract: This article provides new insight into the connection between the trace-based lower part of van Glabbeek’s linear-time, branching-time spectrum and its simulation-based upper part. We establish that ready simulation is fully abstract with respect to failure inclusion, when adding the conjunction operator that was proposed by the authors in [TCS 373 (1–2) 19–40] to the standard setting of labelled transition systems with (CSP-style) parallel composition. More precisely, we actually prove a stronger result by considering a coarser relation than failure inclusion, namely a preorder that relates processes with respect to inconsistencies that may arise under conjunctive composition. Ready simulation is also shown to satisfy standard logic properties. In addition, our semantic formalism proves itself robust when adding disjunction, external choice and hiding operators, and is thus suited for studying mixed operational and logic languages. Finally, the utility of our formalism is demonstrated by means of a small example that deals with specifying and reasoning about mode logics within aircraft control systems. [Copyright &y& Elsevier]

Abstract: We propose means to predict termination in a higher-order imperative and concurrent language à la ML. We follow and adapt the classical method for proving termination in typed formalisms, namely the realizability technique. There is a specific difficulty with higher-order state, which is that one cannot define a realizability interpretation simply by induction on types, because applying a function may have side-effects at types not smaller than the type of the function. Moreover, such higher-order side-effects may give rise to computations that diverge without resorting to explicit recursion. We overcome these difficulties by introducing a type and effect system for our language that enforces a stratification of the memory. The stratification prevents the circularities in the memory that may cause divergence, and allows us to define a realizability interpretation of the types and effects, which we then use to establish that typable sequential programs in our system are guaranteed to terminate, unless they use explicit recursion in a divergent way. We actually prove a more general fairness property, that is, any typable thread yields the scheduler after some finite computation. Our realizability interpretation also copes with dynamic thread creation. [Copyright &y& Elsevier]

In this paper, we report on the results of a case study aimed at selecting a prospective CA system to be used by the Mizar proof-checking system for performing computations of Grobner bases in Mizar's module responsible for equality calculus. A rudimentary interface has been implemented for each of considered CA systems, and tested in order to assess its feasibility in connection with the Mizar proof checker. [ABSTRACT FROM AUTHOR]

The notion of persistency, based on the rule "no action can disable another one" is one of the classical notions in concurrency theory. We propose two ways of generalization of this notion: the first is "no action can kill another one" and the second "no action can kill another enabled one". We study the three notions in the context of place/transition nets, the fundamental class of Petri nets. We prove that the three classes of persistency form an increased strict hierarchy. The final section of the paper deals with decision problems about persistency. We show that the set reachability problem is decidable for rational convex sets, and using this result we prove that all kinds of persistency are decidable in the class place/transition nets. [ABSTRACT FROM AUTHOR]

Abstract: LMNtal (pronounced “elemental”) is a simple language model based on hierarchical graph rewriting that uses logical variables to represent connectivity and membranes to represent hierarchy. LMNtal is an outcome of the attempt to unify constraint-based concurrency and Constraint Handling Rules (CHR), the two notable extensions to concurrent logic programming. LMNtal is intended to be a substrate language of various computational models, especially those addressing concurrency, mobility and multiset rewriting. Although the principal objective of LMNtal was to provide a unifying computational model, it is of interest to equip the formalism with a precise logical interpretation. In this paper, we show that it is possible to give LMNtal a simple logical interpretation based on intuitionistic linear logic and a flattening technique. This enables us to call LMNtal a hierarchical, concurrent linear logic language. [Copyright &y& Elsevier]

Abstract: This paper formalizes the observable interface behavior of a concurrent, object-oriented language with futures and promises. The calculus captures the core of Creol, a language, featuring in particular asynchronous method calls and, since recently, first-class futures. The focus of the paper are open systems and we formally characterize their behavior in terms of interactions at the interface between the program and its environment. The behavior is given by transitions between typing judgments, where the absent environment is represented abstractly by an assumption context. A particular challenge is the safe treatment of promises: The erroneous situation that a promise is fulfilled twice, i.e., bound to code twice, is prevented by a resource aware type system, enforcing linear use of the write-permission to a promise. We show subject reduction and the soundness of the abstract interface description. [Copyright &y& Elsevier]

Frequent itemset mining is often regarded as advanced querying where a user specifies the source dataset and pattern constraints using a given constraint model. In this paper we address the problem of processing batches of frequent itemset queries using the Apriori algorithm. The best solution of this problem proposed so far is Common Counting, which consists in concurrent execution of the queries using Apriori with the integration of scans of the parts of the database shared among the queries. In this paper we propose a new method - Common Candidate Tree, offering a more tight integration of the concurrently processed queries by sharing memory data structures, i.e., candidate hash trees. The experiments show that Common Candidate Tree outperforms Common Counting in terms of execution time. Moreover, thanks to smaller memory consumption, Common Candidate Tree can be applied to larger batches of queries. [ABSTRACT FROM AUTHOR]

When numerous users and applications work concurrently on Extensible Markup Language (XML) documents, the transaction management of these XML documents becomes an important issue. The detection of conflicts between operations becomes vital in the query optimization for a query compiler and concurrency for a transaction manager. XML data require tailor-made conflict detection mechanisms since traditional solutions for the relational model are inadequate. Such mechanisms need to take full advantage of the hierarchical structure of semi-structured data. In this paper, we will solve a fundamental problem of the concurrency control for valid XML documents, which is the detection of conflicts between operations. We will formalize READ-UPDATE and UPDATE-UPDATE conflicts in valid XML documents, and propose effective algorithms to detect such conflict when the update operations are specified using XPath expressions. Furthermore, we will show that our proposed optimistic concurrency control scheme is a solution to the phantom and the pseudo-conflict problems. [ABSTRACT FROM AUTHOR]

In this paper, we present a method to generate abstractions for model checking concurrent systems. A program using a defined syntax and semantics, first describes the concurrent system that can be infinite. This program is abstracted using the framework of abstract interpretation where an abstract function will be given. This abstract program is demonstrated to be an accurate approximation of the original program that may contain spurious behaviours. These spurious behaviours will be identified and removed using a new defined abstraction framework based on the restrictions. The new produced abstract program is an exact approximation of the original program. [ABSTRACT FROM AUTHOR]

In this paper we propose an extension of the functional programming language Caml, exactly Caml Light, that allows it to express concurrent and distributed applications; we call the resulting language Distributed Carol Light. This proposed language will be developed further to support the mobile computation paradigm. For the concurrent and distributed extension of Caml Light, we use the model of ERLANG functional programming language in spite of its simplicity on the one hand and of its success in the development of applications in this area on the other hand. In Distributed Carol Light, processes communicate with each other by sending asynchronous messages. Writing distributed programs in Distributed Caml Light is made by the adaptation of functions' used for concurrency. [ABSTRACT FROM AUTHOR]

Abstract: Orc is a kernel language for structured concurrent programming. Orc provides three powerful combinators that define the structure of a concurrent computation. These combinators support sequential and concurrent execution, and concurrent execution with blocking and termination. Orc is particularly well-suited for task orchestration, a form of concurrent programming with applications in workflow, business process management, and web service orchestration. Orc provides constructs to orchestrate the concurrent invocation of services while managing time-outs, priorities, and failures of services or communication. Our previous work on the semantics of Orc focused on its asynchronous behavior. The inclusion of time or the effect of delay on a computation had not been modeled. In this paper, we define an operational semantics of Orc that allows reasoning about delays, which are introduced explicitly by time-based constructs or implicitly by network delays. We develop a number of identities among Orc expressions and define an equality relation that is a congruence. We also present a denotational semantics in which the meaning of an Orc program is a set of traces, and show that the two semantics are equivalent. [Copyright &y& Elsevier]

We study the complexity of temporal logics over concurrent systems that can be described by Mazurkiewicz traces. We develop a general method to prove that the uniform satisfiability problem of local temporal logics is in PSPACE. We also demonstrate that this method applies to all known local temporal logics. [ABSTRACT FROM AUTHOR]

Concurrent runs reveal more insight into distributed systems than interleaved runs. This is shown by help of Dijkstra's paradigm of five philosophers. [ABSTRACT FROM AUTHOR]

An alternator is a network of concurrent nodes, which satisfies the following conditions: (i) if one node enters its critical section, no neighboring nodes could enter their critical sections at the same computing phase; (ii) along any infinite computing phases, each node enters its critical section infinitely often. An alternator is said to exhibit strong fairness if condition (ii) is changed to: between any two consecutive critical steps of a node, all neighbors enter their critical sections exactly once. In this paper, we propose a state-optimal alternator algorithm for uniform rings with n nodes, where n is any positive integer greater than one. The proposed algorithm operates correctly for synchronous mode. Every node maintains only a two-state variable. The proposed algorithm has the snap property that the system always satisfies condition (i) of the alternator even if some transient fault occurs. The stabilization time of the proposed alternator algorithm is O(n) phases. After stabilization, the system satisfies the strong fairness property and achieves the maximal performance. We say that an alternator achieves the maximal performance if a node is allowed to enter its critical section when both its neighbors do not enter their critical sections. In the worst case, the proposed algorithm allows each node to enter its critical section every three phases. [ABSTRACT FROM AUTHOR]

Model checking based on Petri net unfoldings is an approach widely applied to cope with the state space explosion problem. In this paper, we propose a new condensed representation of a Petri net’s behaviour called merged processes, which copes well not only with concurrency, but also with other sources of state space explosion, viz sequences of choices and non-safeness. Moreover, this representation is sufficiently similar to the traditional unfoldings, so that a large body of results developed for the latter can be re-used. Experimental results indicate that the proposed representation of a Petri net’s behaviour alleviates the state space explosion problem to a significant degree and is suitable for model checking. [ABSTRACT FROM AUTHOR]

We present a method for selecting test sequences for concurrent programs from labeled transitions systems (LTS). A common approach to selecting test sequences from a set of LTSs is to derive a global LTS, called the reachability graph, and then force deterministic program executions according to paths selected from the graph. However, using a reachability graph for test path selection introduces a state explosion problem. To overcome this problem, a reduced graph can be generated using incremental reachability analysis, which consists of repeatedly generating a reachability graph for a subset of LTSs, reducing this graph, and using the reduced graph in place of the original LTSs. Unfortunately, existing incremental reachability analysis techniques generate reduced graphs with insufficient information for deterministic testing. In this paper, we present an incremental approach to testing concurrent programs. Incremental testing consists of incremental reachability analysis for test path selection and deterministic testing for test execution. We define a new type of reachability graph for incremental analysis, called an annotated labeled transition system (ALTS). An ALTS is an LTS annotated with information necessary for deterministic testing. We propose practical coverage criteria for selecting tests paths from an ALTS and present an ALTS reduction algorithm. The results of several case studies are reported. [ABSTRACT FROM AUTHOR]

Applications of computers to humanistic research rely increasingly on SGML or XML markup; it is a persistent challenge to find suitable representations in these tree-based formalisms, for the overlap of textual features. SGML lends itself to a straightforward data model with a simple relationship between markup (element and attributes) and features or structures in the text. Barnard et al. (Computers and the Humanities, 22: 265-76, 1988; 29: 21131, 1995) and TEI (Guidelines for Electronic Text Encoding and Interchange, 1994) have presented methods for registering the existence of overlap using SGML notations, but these methods are often felt to be unsatisfactory, in part (we argue) because they complicate the otherwise straightforward SGML data model. The MECS and CONCUR notations described here allow the straightforward markup of overlapping textual features. CONCUR further allows the formulation of useful document grammars for concurrent hierarchies of textual features. The theoretical and practical advantages outweigh the practical disadvantages, and the humanities computing community should begin serious experimentation with CONCUR. [ABSTRACT FROM AUTHOR]

ILIAD is a high-level language for programming real-time applications which involve concurrent processing. It was designed to help scientists and engineers write reliable programs that can be read and maintained. An ILIAD program consists of a group of concurrent tasks. The tasks are autonomous and must cooperate in using the shared memory and devices in the execution environment. The language has facilities for providing secure access to these resources and for creating and synchronizing parallel instruction streams. In providing an overview of the language, the factors motivating the major design choices are discussed. A programming example illustrates how ILIAD might be applied. An assessment of the language includes a discussion of potential problem areas, both technical and nontechnical. [ABSTRACT FROM AUTHOR]

The article focuses on the application of datalog programming in the domains of security, web data extraction, concurrent programming, and answer-set programming. It discusses the computer applications and also their uses. It mentions that the web data extraction tools are used to aggregate information relevant to a particular topic from different websites and answer-set is a form of logic programming that helps in solving search problems that may have multiple satisfying model.