Run-time Conflicts Research Articles

Transaction Scheduling: From Conflicts to Runtime Conflicts

This paper studies how to improve the performance of main memory multicore OLTP systems for executing transactions with conflicts. A promising approach is to partition transaction workloads into mutually conflict-free clusters, and distribute the clusters to different cores for concurrent execution. We show that if transactions in each cluster are properly scheduled, transactions that are traditionally considered conflicting can be executed without conflicts at runtime. In light of this, we propose to schedule transactions and reduce runtime conflicts, instead of partitioning based on the conventional notion of conflicts. We formulate the transaction scheduling problem to minimize runtime conflicts, and show that the problem is NP-complete. This said, we develop an efficient scheduling algorithm to improve parallelism. Moreover, for transactions that are not packed in batches, we show that runtime conflict analysis also helps reduce conflict penalties, by proposing a proactive deferring method. Using standard and enhanced benchmarks, we show that on average our scheduling and proactive deferring methods improve the throughput of existing partitioners and concurrency control protocols by 131% and 109%, respectively, up to 294% and 152%.

Run-time conflict detection in visual language parsing

Abstract The widespread use of diagrammatic languages has motivated the need for grammar-based tools to support designers in the definition and implementation of graphical environments. The effective use of such systems requires efficient parsing techniques. In previous years, many approaches have been devised and one of them is based on the extension of the LR parsing methodology from traditional string languages to visual languages generated by the so-called Positional Grammars. The technique, named pLR parsing, is a deterministic technique able to automatically generate an efficient LR-like parser for many interesting and practical visual languages such as flowcharts, statecharts, automata, UML notations, and others. However, differently from the traditional string case, there exist particular positional grammars whose generated pLR parsing table does not present conflicts but are, however, not pLR parsable because, due to their two-dimensional nature, they can produce run-time conflicts. In this paper, we introduce an algorithm that statically verifies the pLR parsability of a positional grammar by detecting whether the pLR parser built on it may produce run-time conflicts. Such an algorithm is of importance during the implementation of a diagrammatic language since it is able to inform the language designer about the pLR parsability of the designed grammar and to detect the (possible) places where the grammar should be modified.

Investigation of feature run-time conflicts on goal model-based reuse

A fundamental task when reusing software artifacts is to determine the most appropriate artifact for the current reuse context. Goal modeling allows modelers to capture the advantages and disadvant...

Implementing Substations Automatic Control Functions Designed With Petri Nets on IEC 61850

This paper shows how cooperative automatic control functions in transmission substations, specified by Petri Nets (PN), fit the IEC 61850 standard. In the PN model, each automaton is specified by an interpreted state machine communicating with others through shared conditions, featuring operational improvements and still ensuring good behavior, as it can be proven through formal analysis. However, to avoid jeopardizing the good properties of the model in a distributed implementation, a few rules on how to split the functions in concurrent tasks must be followed, particularly on how some runtime conflicts have to be resolved. Although the IEC 61850 environment provides a set of communication services for the substations functions, implementing PN specifications on it is not a straightforward process. Therefore, a new class of logical nodes is proposed to model the functions required for that purpose.

A Policy-Oriented Reputation BDI Model

Computational trust and reputation models have been recognized as one of the key technologies required to design and implement agent systems. These models manage and aggregate the information needed by agents to efficiently perform partner selection in uncertain situations. In this paper, by taking advantage of the non-monotonic knowledge representation and reasoning mechanisms of defeasible logic, a reputation-Oriented Agent model is proposed, which is capable of accepting policy guidance, the real-time rule modifications, and handling the run-time rule conflicts. This agent is both autonomous and controllable, and is able to cooperate with other Agents via contracts in an open and dynamic environment.

ProMINoC: An efficient Network-on-Chip design for flexible data permutation

This paper presents a novel Network-on-Chip design to efficiently support data-interleaving with arbitrary permutation rule. The proposed NoC offers a run-time conflict resolution for interleaved data under arbitrary permutation rule by using a circuit-switching approach combined with a dynamic path-probing scheme. Experimental results in a 0.18µm STD-cell CMOS process show that the proposed NoC can offer an aggregate bandwidth of up to 522.4Gb/s, while occupying a compact area of 0.473mm2 (52kGates). A comparison with other interleaving networks shows the efficiency of the proposed design.

Solving the starting problem

Run-time conflicts can affect even the most rigorously tested software systems. A reliance on execution-based testing makes it prohibitively costly to test every possible interaction among potentially thousands of programs with complex configurations. In order to reduce configuration problems, detect developer errors, and reduce developer effort, we have created a new first class operating system abstraction, the application abstraction, which enables both online and offline reasoning about programs and their configuration requirements.We have implemented a subset of the application abstraction for device drivers in the Singularity operating system. Programmers use the application abstraction by placing declarative statements about hardware and communication requirements within their code. Our design enables Singularity to learn the input/output and interprocess communication requirements of drivers without executing driver code. By reasoning about this information within the domain of Singularity's strong software isolation architecture, the installer can execute a subset the system's resource management algorithm at install time to verify that a new driver will not conflict with existing software. This abstract representation also allows the system to run the full algorithm at driver start time to ensure that there are never resource conflicts between executing drivers, and that drivers never use undeclared resources.

Communication and coordination in multi-agent manufacturing systems

Communication and coordination are indispensable for achieving common goals in multi-agent manufacturing systems. Without a coordinator, manager or a facilitator, potential conflicts may become obstacles during runtime. In addition, a lack of an efficiently coordinated communication would result in the duplication of efforts. Without a well-coordination mechanism, it will be chaotic to involve different functional agents in a Multi-Agent Manufacturing System (MAMS). The operations of multiple agents need to be coordinated because of the inter-dependency that exists between the actions of these agents and the need to resolve run-time conflicts that may occur during evaluation or negotiation. Hence, an efficient coordination mechanism is crucial for a distributed manufacturing system for performing activities in a shared environment. In this paper, a centralised coordination method for manufacturing services based on priorities and conflict resolution is presented, and a coordinated system to resolve conflicts during runtime has also been developed.

E-DEVICE: an extensible active knowledge base system with multiple rule type support

This paper describes E-DEVICE, an extensible active knowledge base system (KBS) that supports the processing of event-driven, production, and deductive rules into the same active OODB system. E-DEVICE provides the infrastructure for the smooth integration of various declarative rule types, such as production and deductive rules, into an active OODB system that supports low-level event-driven rules only by: (1) mapping each declarative rule into one event-driven rule, offering centralized rule selection control for correct run-time behavior and conflict resolution, and (2) using complex events to map the conditions of declarative rules and monitor the database to incrementally match those conditions. E-DEVICE provides the infrastructure for easily extending the system by adding: (1) new rule types as subtypes of existing ones, and (2) transparent optimizations to the rule matching network. The resulting system is a flexible, yet efficient, KBS that gives the user the ability to express knowledge in a variety of high-level forms for advanced problem solving in data intensive applications.