Abstract. We describe some of the novel aspects and motivations behind the design and implementation of the Ciao multiparadigm programming system. An important aspect of Ciao is that it provides the programmer with a large number of useful features from different programming paradigms and styles, and that the use of each of these features can be turned on and off at will for each program module. Thus, a given module may be using e.g. higher order functions and constraints, while another module may be using objects, predicates, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of program optimizations. Such optimizations produce code that is highly competitive with other dynamic languages or, when the highest

Abstract. We present two new algorithms which perform automatic parallelization via source-to-source transformations. The objective is to exploit goal-level, unrestricted independent and-parallelism. The proposed algorithms use as targets new parallel execution primitives which are simpler and more flexible than the well-known &/2 parallel operator. This makes it possible to generate better parallel expressions by exposing more potential parallelism among the literals of a clause than is possible with &/2. The difference between the two algorithms stems from whether the order of the solutions obtained is preserved or not. We also report on a preliminary evaluation of an implementation of our approach. We compare the performance obtained to that of previous annotation algorithms and show that relevant improvements can be obtained.

Abstract. The growing popularity of multicore architectures has renewed interest in language-based approaches to the exploitation of parallelism. Logic programming has proved an interesting framework to this end, and there are parallel implementations which have achieved significant speedups, but at the cost of a quite sophisticated low-level machinery. This machinery has been found challenging to code and, specially, to maintain and expand. In this paper, we follow a different approach which adopts a higher level view by raising some of the core components of the implementation to the level of the source language. We briefly present an implementation model for independent and-parallelism which fully supports non-determinism through backtracking and provides flexible solutions for some of the main problems found in previous andparallel implementations. Our proposal is able to optimize the execution for the case of deterministic programs and to exploit unrestricted andparallelism, which allows exposing more parallelism among clause literals than fork-join-based proposals. We present performance results for an implementation, including data for benchmarks where and-parallelism is exploited in non-deterministic programs. Keywords: And-Parallelism, High-level Implementation, Prolog. 1

The current ubiquity of multi-core processors has brought renewed interest in program parallelization. Logic programs allow studying the parallelization of programs with complex, dynamic data structures with (declarative) pointers in a comparatively simple semantic setting. In this context, automatic parallelizers which exploit and-parallelism rely on notions of independence in order to ensure certain efficiency properties. “Non-strict ” independence is a more relaxed notion than the traditional notion of “strict ” independence which still ensures the relevant efficiency properties and can allow considerable more parallelism. Non-strict independence cannot be determined solely at run-time (“a priori”) and thus global analysis is a requirement. However, extracting non-strict independence information from available analyses and domains is non-trivial. This paper provides on one hand an extended presentation of our classic techniques for compile-time detection of non-strict independence based on extracting information from (abstract interpretation-based) analyses using the now well understood and popular Sharing+Freeness domain. This includes

Parallelism capabilities have become ubiquitous thanks to the wide availability of multicore systems in the market at a reasonable price. Even standard laptops feature several cores and the projection is that the number of cores will double with each generation. As a result, being able to exploit such parallel execution capabilities in programs as easily as possible becomes more and more a necessity. However, parallelizing programs is hard, and thus one of the main issues that difficult the widespread use of parallelism is that few applications are written to exploit parallelism. This fact has renewed interest in the design and development of languages and tools to simplify the task of writing parallel programs, of which parallelizing compilers are a noteworthy instance. Background Declarative languages are considered a promising approach for increasing performance of applications through the execution of parallel programs on multicore architectures, including multicore embedded systems. The comparatively higher level of abstraction of declarative languages, and among them the new multiparadigm languages based on logic programming kernels, allows writing programs which are closer to the specification of the solution and which thus do not obscure the intrinsic parallelism of the problem. In addition, there is often more freedom in the implementation,