13,028 research outputs found
Investigation of design and execution alternatives for the committed choice non-deterministic logic languages
The general area of developing, applying and studying new and parallel models
of computation is motivated by a need to overcome the limits of current Von
Neumann based architectures. A key area of research in understanding how new
technology can be applied to Al problem solving is through using logic languages.
Logic programming languages provide a procedural interpretation for sentences of
first order logic, mainly using a class of sentence called Horn clauses. Horn clauses
are open to a wide variety of parallel evaluation models, giving possible speed-ups
and alternative parallel models of execution.
The research in this thesis is concerned with investigating one class of parallel
logic language known as Committed Choice Non-Deterministic languages. The investigation
considers the inherent parallel behaviour of Al programs implemented
in the CCND languages and the effect of various alternatives open to language
implementors and designers. This is achieved by considering how various Al programming
techniques map to alternative language designs and the behaviour of
these Al programs on alternative implementations of these languages.
The aim of this work is to investigate how Al programming techniques are
affected (qualitatively and quantitatively) by particular language features. The
qualitative evaluation is a consideration of how Al programs can be mapped to
the various CCND languages. The applications considered are general search
algorithms (which focuses on the committed choice nature of the languages); chart
parsing (which focuses on the differences between safe and unsafe languages);
and meta-level inference (which focuses on the difference between deep and flat
languages). The quantitative evaluation considers the inherent parallel behaviour
of the resulting programs and the effect of possible implementation alternatives
on this inherent behaviour. To carry out this quantitative evaluation we have
implemented a system which improves on the current interpreter based evaluation
systems. The new system has an improved model of execution and allows severa
Logic programming in the context of multiparadigm programming: the Oz experience
Oz is a multiparadigm language that supports logic programming as one of its
major paradigms. A multiparadigm language is designed to support different
programming paradigms (logic, functional, constraint, object-oriented,
sequential, concurrent, etc.) with equal ease. This article has two goals: to
give a tutorial of logic programming in Oz and to show how logic programming
fits naturally into the wider context of multiparadigm programming. Our
experience shows that there are two classes of problems, which we call
algorithmic and search problems, for which logic programming can help formulate
practical solutions. Algorithmic problems have known efficient algorithms.
Search problems do not have known efficient algorithms but can be solved with
search. The Oz support for logic programming targets these two problem classes
specifically, using the concepts needed for each. This is in contrast to the
Prolog approach, which targets both classes with one set of concepts, which
results in less than optimal support for each class. To explain the essential
difference between algorithmic and search programs, we define the Oz execution
model. This model subsumes both concurrent logic programming
(committed-choice-style) and search-based logic programming (Prolog-style).
Instead of Horn clause syntax, Oz has a simple, fully compositional,
higher-order syntax that accommodates the abilities of the language. We
conclude with lessons learned from this work, a brief history of Oz, and many
entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic
Programming
Blazes: Coordination Analysis for Distributed Programs
Distributed consistency is perhaps the most discussed topic in distributed
systems today. Coordination protocols can ensure consistency, but in practice
they cause undesirable performance unless used judiciously. Scalable
distributed architectures avoid coordination whenever possible, but
under-coordinated systems can exhibit behavioral anomalies under fault, which
are often extremely difficult to debug. This raises significant challenges for
distributed system architects and developers. In this paper we present Blazes,
a cross-platform program analysis framework that (a) identifies program
locations that require coordination to ensure consistent executions, and (b)
automatically synthesizes application-specific coordination code that can
significantly outperform general-purpose techniques. We present two case
studies, one using annotated programs in the Twitter Storm system, and another
using the Bloom declarative language.Comment: Updated to include additional materials from the original technical
report: derivation rules, output stream label
The Transactional Conflict Problem
The transactional conflict problem arises in transactional systems whenever
two or more concurrent transactions clash on a data item.
While the standard solution to such conflicts is to immediately abort one of
the transactions, some practical systems consider the alternative of delaying
conflict resolution for a short interval, which may allow one of the
transactions to commit. The challenge in the transactional conflict problem is
to choose the optimal length of this delay interval so as to minimize the
overall running time penalty for the conflicting transactions. In this paper,
we propose a family of optimal online algorithms for the transactional conflict
problem.
Specifically, we consider variants of this problem which arise in different
implementations of transactional systems, namely "requestor wins" and
"requestor aborts" implementations: in the former, the recipient of a coherence
request is aborted, whereas in the latter, it is the requestor which has to
abort. Both strategies are implemented by real systems.
We show that the requestor aborts case can be reduced to a classic instance
of the ski rental problem, while the requestor wins case leads to a new version
of this classical problem, for which we derive optimal deterministic and
randomized algorithms.
Moreover, we prove that, under a simplified adversarial model, our algorithms
are constant-competitive with the offline optimum in terms of throughput.
We validate our algorithmic results empirically through a hardware simulation
of hardware transactional memory (HTM), showing that our algorithms can lead to
non-trivial performance improvements for classic concurrent data structures
Handshaking Protocol for Distributed Implementation of Reo
Reo, an exogenous channel-based coordination language, is a model for service
coordination wherein services communicate through connectors formed by joining
binary communication channels. In order to establish transactional
communication among services as prescribed by connector semantics, distributed
ports exchange handshaking messages signalling which parties are ready to
provide or consume data. In this paper, we present a formal implementation
model for distributed Reo with communication delays and outline ideas for its
proof of correctness. To reason about Reo implementation formally, we introduce
Timed Action Constraint Automata (TACA) and explain how to compare TACA with
existing automata-based semantics for Reo. We use TACA to describe handshaking
behavior of Reo modeling primitives and argue that in any distributed circuit
remote Reo nodes and channels exposing such behavior commit to perform
transitions envisaged by the network semantics.Comment: In Proceedings FOCLASA 2014, arXiv:1502.0315
Graphical modelling language for spycifying concurrency based on CSP
Introduced in this (shortened) paper is a graphical modelling language for specifying concurrency in software designs. The language notations are derived from CSP and the resulting designs form CSP diagrams. The notations reflect both data-flow and control-flow aspects of concurrent software architectures. These designs can automatically be described by CSP algebraic expressions that can be used for formal analysis. The designer does not have to be aware of the underlying mathematics. The techniques and rules presented provide guidance to the development of concurrent software architectures. One can detect and reason about compositional conflicts (errors in design), potential deadlocks (errors at run-time), and priority inversion problems (performance burden) at a high level of abstraction. The CSP diagram collaborates with objectoriented modelling languages and structured methods
- …