Abstract not found

It is well known that adding side effects to functional languages changes the operational equivalences of the language. We develop a new language construct, encap, that forces imperative pieces of code to behave purely functionally, i.e., without any visible side effects. The coercion operator encap provides a means of extending the simple reasoning principles for equivalences of code in a functional language to a language with side effects. In earlier work [36], similar coercion operators were developed, but their correctness required the underlying functional language to include parallel operations. The coercion operators developed here are simpler and are proven correct for purely sequential languages. The sequential setting requires the construction of fully abstract models for sequential call-by-value languages and the formulation of a weak form of "monad" suitable for expressing the semantics of call-by-value languages with side effects. 1 Introduction Two pieces of code are...

Dynamic granularity estimation is a new technique for automatically identifying expressions in functional languages for parallel evaluation. Expressions with little computation relative to thread-creation costs should evaluate sequentially for maximum performance. Static identification of such threads is however difficult. Therefore, dynamic granularity estimation has compile-time and run-time components: Abstract interpretation statically identifies functions whose complexity depends on data structure sizes; the run-time system maintains approximations to these sizes. Compiler-inserted checks consult this size information to make thread creation decisions dynamically. We describe dynamic granularity estimation for a list-based functional language. Extension to general recursive data structures and imperative operations is possible. Performance measurements of dynamic granularity estimation in a parallel ML implementation on a shared-memory machine demonstrate the possibility of large...

Distributed parallel execution systems speed up applications by splitting tasks into processes whose execution is assigned to di#erent receiving nodes in a high-bandwidth network. On the distributing side, a fundamental problem is grouping and scheduling such tasks such that each one involves su#cient computational cost when compared to the task creation and communication costs and other such practical overheads.

We describe an interprocedural technique, called dynamic resolution, for the automatic parallelization of procedures that destructively manipulate dynamic DAGs. Dynamic resolution dynamically detects shared data and correctly coordinates access to this data at run time. In pointer-unsafe languages (e.g., C), dynamic resolution requires programmer identification of acyclic data structures and the use of dynamic resolution's macros for pointer manipulations; parallelization is then automatic. In pointer-safe languages (e.g., ML), cyclicity can often be automatically inferred by the compiler and parallelization via dynamic resolution is completely automatic. This paper empirically studies the performance of dynamic resolution. Our study reveals that dynamic parallelization can readily outperform optimized sequential C programs on fast contemporary hardware. In particular, implementations of two general problems (DAG rewrite and in-place list quicksort) using dynamic resolution and three p...

Automatic parallelization has become a mainstream research topic for different reasons. For example, multicore architectures, which are now present even in laptops, have awakened an interest in software tools that can exploit the computing power of parallel processors. Distributed and (multi)agent systems also benefit from techniques and tools for deciding in which locations should processes be run to make a better use of the available resources. Any decision on whether to execute some processes in parallel or sequentially must ensure correctness (i.e., the parallel execution obtains the same results as the sequential), but also has to take into account a number of practical overheads, such as those associated with tasks creation, possible migration of tasks to remote processors, the associated communication overheads, etc. Due to these overheads and if the granularity of parallel tasks, i.e., the “work available ” underneath them, is too small, it may happen that the costs are larger than the benefits in their parallel execution. Thus, the aim of granularity control is to change parallel execution to sequential execution or vice-versa based on some conditions related to grain size and overheads. In this work, we have applied fuzzy logic to automatic granularity control in parallel/distributed computing and proposed fuzzy conditions for deciding whether to execute some given tasks in parallel or sequentially. We have compared our proposed fuzzy conditions with existing (conservative) sufficient conditions and our experiments showed that the proposed fuzzy conditions result in more efficient executions on average than the conservative conditions. 1

Logic Programming Languages offer an excellent framework for the application of automatic parallelization techniques. On the other hand, there are theoretical results that ensure when parallel(ized) programs are correct (i.e. obtain the same results as their corresponding sequential ones), and when execution of parallel (ized) programs do not take longer than that of the sequential ones. However, such results do not take into account a number of overheads which appear in practice, such as process creation and scheduling, which can induce a slow-down, or, at least, limit speedup, if they are not controlled in some way. In this dissertation, we have developed (an integrated in an advanced system for program analysis, debugging and optimization) a complete automatic granularity control system for logic programs whereby the granularity of parallel tasks, i.e. the work needed for their complete execution, is efficiently estimated and used to limit parallelism so that the effect of the mentioned overheads is controlled. The system is based on a program analysis and transformation scheme, where as much work is done at compile time as possible in order to avoid the introduction of runtime overheads. For this purpose we have developed some program transformation techniques, so that transformed programs perform an efficient granularity control at runtime, and also have developed some program analysis techniques able to infer the information needed for the program transformation phase, such as (lower bounds on) cost of procedures, which calls will not fail (non-failure analysis), etc.

Abstract not found