19 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
PrologPF: Parallel Logic and Functions on the Delphi Machine
PrologPF is a parallelising compiler targeting a distributed system of general purpose workstations connected by a relatively low performance network. The source language extends standard Prolog with the integration of higher-order functions.
The execution of a compiled PrologPF program proceeds in a similar manner to standard Prolog, but uses oracles in one of two modes. An oracle represents the sequence of clauses used to reach a given point in the problem search tree, and the same PrologPF executable can be used to build oracles, or follow oracles previously generated.
The parallelisation strategy used by PrologPF proceeds in two phases, which this research shows can be interleaved. An initial phase searches the problem tree to a limited depth, recording the discovered incomplete paths. In the second phase these paths are allocated to the available processors in the network. Each processor follows its assigned paths and fully searches the referenced subtree, sending solutions back to a control processor. This research investigates the use of the technique with a one-time partitioning of the problem and no further scheduling communication, and with the recursive application of the partitioning technique to effect dynamic work reassignment.
For a problem requiring all solutions to be found, execution completes when all the distributed processors have completed the search of their assigned subtrees. If one solution is required, the execution of all the path processors is terminated when the control processor receives the first solution.
The presence of the extra-logical Prolog predicate cut in the user program conflicts with the use of oracles to represent valid open subtrees. PrologPF promotes the use of higher-order functional programming as an alternative to the use of cut. The combined language shows that functional support can be added as a consistent extension to standard Prolog
Tools and Models for High Level Parallel and Grid Programming
When algorithmic skeletons were first introduced by Cole in late 1980 the
idea had an almost immediate success. The skeletal approach has been proved to
be effective when application algorithms can be expressed in terms of skeletons
composition. However, despite both their effectiveness and the progress made in
skeletal systems design and implementation, algorithmic skeletons remain absent
from mainstream practice. Cole and other researchers, focused the problem. They
recognized the issues affecting skeletal systems and stated a set of principles
that have to be tackled in order to make them more effective and to take
skeletal programming into the parallel mainstream. In this thesis we propose
tools and models for addressing some among the skeletal programming
environments issues. We describe three novel approaches aimed at enhancing
skeletons based systems from different angles. First, we present a model we
conceived that allows algorithmic skeletons customization exploiting the macro
data-flow abstraction. Then we present two results about the exploitation of
meta-programming techniques for the run-time generation and optimization of
macro data-flow graphs. In particular, we show how to generate and how to
optimize macro data-flow graphs accordingly both to programmers provided
non-functional requirements and to execution platform features. The last result
we present are the Behavioural Skeletons, an approach aimed at addressing the
limitations of skeletal programming environments when used for the development
of component-based Grid applications. We validated all the approaches
conducting several test, performed exploiting a set of tools we developed.Comment: PhD Thesis, 2008, IMT Institute for Advanced Studies, Lucca. arXiv
admin note: text overlap with arXiv:1002.2722 by other author
Parallelism in Constraint Programming
Writing efficient parallel programs is the biggest challenge of the software industry for the foreseeable future. We are currently in a time when parallel computers are the norm, not the exception. Soon, parallel processors will be standard even in cell phones. Without drastic changes in hardware development, all software must be parallelized to its fullest extent. Parallelism can increase performance and reduce power consumption at the same time. Many programs will execute faster on a dual-core processor than a single core processor running at twice the speed. Halving the speed of a processor can reduce the power consumption up to four times. Hence, parallelism gives more performance per unit of power to efficient programs. In order to make use of parallel hardware, we need to overcome the difficulties of parallel programming. To many programmers, it is easier to learn a handful of small domain-specific programming languages than to learn efficient parallel programming. The frameworks for these languages can then automatically parallelize the program. Automatically parallelizing traditional programs is usually much more difficult. In this thesis, we study and present parallelism in constraint programming (CP). We have developed the first constraint framework that automatically parallelizes both the consistency and the search of the solving process. This allows programmers to avoid the difficult issues of parallel programming. We also study distributed CP with independent agents and propose solutions to this problem. Our results show that automatic parallelism in CP can provide very good performance. Our parallel consistency scales very well for problems with many large constraints. We also manage to combine parallel consistency and parallel search with a performance increase. The communication and load-balancing schemes we developed increase the scalability of parallel search. Our model for distributed CP is orders of magnitude faster than traditional approaches. As far as we know, it is the first to solve standard benchmark scheduling problems
Tools and models for high level parallel and Grid programming
When algorithmic skeletons were first introduced by Cole in
late 1980 (50) the idea had an almost immediate success. The
skeletal approach has been proved to be effective when application algorithms can be expressed in terms of skeletons composition. However, despite both their effectiveness and the progress made in skeletal systems design and implementation, algorithmic skeletons remain absent from mainstream practice. Cole and other researchers, respectively in (51) and (19), focused the problem. They recognized the issues affecting
skeletal systems and stated a set of principles that have
to be tackled in order to make them more effective and to
take skeletal programming into the parallel mainstream. In
this thesis we propose tools and models for addressing some
among the skeletal programming environments issues. We
describe three novel approaches aimed at enhancing skeletons
based systems from different angles. First, we present a model we conceived that allows algorithmic skeletons customization exploiting the macro data-flow abstraction. Then we present two results about the exploitation of metaprogramming techniques for the run-time generation and optimization of macro data-flow graphs. In particular, we show how to generate and how to optimize macro data-flow graphs accordingly both to programmers provided non-functional requirements and to execution platform features. The last result we present are the Behavioural Skeletons, an approach aimed at addressing the limitations of skeletal programming environments when used for the development of component-based Grid applications.
We validated all the approaches conducting several test,
performed exploiting a set of tools we developed
The exploitation of parallelism on shared memory multiprocessors
PhD ThesisWith the arrival of many general purpose shared memory multiple processor
(multiprocessor) computers into the commercial arena during the mid-1980's, a
rift has opened between the raw processing power offered by the emerging
hardware and the relative inability of its operating software to effectively deliver
this power to potential users. This rift stems from the fact that, currently, no
computational model with the capability to elegantly express parallel activity is
mature enough to be universally accepted, and used as the basis for programming
languages to exploit the parallelism that multiprocessors offer. To add to this,
there is a lack of software tools to assist programmers in the processes of designing
and debugging parallel programs.
Although much research has been done in the field of programming languages,
no undisputed candidate for the most appropriate language for programming
shared memory multiprocessors has yet been found. This thesis examines why this
state of affairs has arisen and proposes programming language constructs,
together with a programming methodology and environment, to close the ever
widening hardware to software gap.
The novel programming constructs described in this thesis are intended for use
in imperative languages even though they make use of the synchronisation
inherent in the dataflow model by using the semantics of single assignment when
operating on shared data, so giving rise to the term shared values. As there are
several distinct parallel programming paradigms, matching flavours of shared
value are developed to permit the concise expression of these paradigms.The Science and Engineering Research Council
An efficient sequential BTRS implementation
Thesis (S.M.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2009.Includes bibliographical references (leaves 73-74).This thesis describes the implementation of BTRS, a language based on guarded atomic actions (GAA). The input language to the compiler which forms the basis of this work is a hierarchical tree of modules containing state, interface methods, and rules which fire atomically to cause state transitions. Since a schedule need not be specified, the program description is inherently nondeterministic, though the BTRS language does allow the programmer to remove nondeterminism by specifying varying degrees of scheduling constraints. The compiler outputs a (sequential) single-threaded C implementation of the input description, choosing a static schedule which adheres to the input constraints. The resulting work is intended to be used as the starting point for research into efficient software synthesis from guarded atomic actions, and ultimately a hardware inspired programming methodology for writing parallel software. This compiler is currently being used to generate software for a heterogeneous system in which the software and hardware components are both specified in BTRS.by Myron Decker King.S.M
Recommended from our members
Concurrent Execution of Mutually Exclusive Alternatives
We examine the task of concurrently computing alternative solutions to a problem. We restrict our interest to the case where only one solution is needed: in this case we need some rule for selecting between the solutions. We use "fastest first," where the first successful alternative is selected. For problems where the required execution time is unpredictable this method can show substantial execution time performance increases. These increases are dependent on the mean execution time of the alternatives, the fastest execution time, the overhead involved in concurrent computation, and the overhead of selecting and deleting alternatives. Rather than using the traditional approach of multiple computers cooperating on the solution to a problem, this method achieves a solution competitively. Among the problems with exploring multiple alternatives in parallel are side-effects and combinatorial explosion in the amount of state which must be preserved. These are solved by process management and an application of "copy-on-write" virtual memory management. The side effects resulting from interprocess communication are handled by a specialized message layer which interacts with process management. We show how the scheme for parallel execution can be applied to several application areas. The applications are distributed execution of recovery blocks, OR-parallelism in Prolog, and polynomial root-finding