Resource analyses for parallel and distributed coordination

Trinder, Phil; Cole, Murray; Hammond, Kevin; Loidl, Hans-Wolfgang; Michaelson, Greg

doi:10.1002/cpe.1898

Cited by 11 publications

(5 citation statements)

References 102 publications

(141 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Abstract interpretation techniques addressing domains carrying quantitative information, such as resource consumption, have been proposed in the literature -see references in [16]. Consequently, several well-developed automatic solvers for cost analysis already exist.…”

Section: Related Workmentioning

confidence: 99%

Time analysis of actor programs

Laneve

Lienhardt

Pun

et al. 2019

Journal of Logical and Algebraic Methods in Programming

View full text Add to dashboard Cite

This paper proposes a technique for estimating the computational time of programs in an actor model, which is intended to serve as a compiler target of a wide variety of actor-based programming languages. We define a compositional translation function returning cost equations, which are fed to an automatic off-the-shelf solver for obtaining the time bounds. Our approach is based on a new notion of synchronization sets, which captures possible difficult synchronization patterns between actors and helps make the analysis efficient and precise. The approach is proven to correctly over-approximate the worst computational time of an actor model of concurrent programs. Our technique is complemented by a prototype analyzer that returns upper bound of costs for the actor model.feeding the cost equations produced by a translation function to a off-the-shelf solver, namely the CoFloCo solver [8].However, this technique proposed in [9] has a very severe constraint: invocations were admitted only either on the same actor or on newly created ones, i.e., no invocation on parameters. For instance, according to this constraint, an invocation to a method inner(y, x), where the first parameter is the actor executing the method, cannot occur in the body of a method outer(x, y). The challenge is that, in this case, computing the cost of outer(x, y) requires to know whether there is a synchronization between actors x and y. In case there is, one has to consider that inner(y, x) might be delayed by other methods running on y, which might be independent from outer(x, y).This paper focuses on overcoming this issue. We first compute synchronization sets of actors, which are actors that potentially might interfere with the executions of each other. We then compose the cost of an invocation with the cost of the callee in two ways: (1) it is added, corresponding to sequential compositions, if the arguments of the invocation and those of the caller are in the same synchronization set; (2) it is the maximum value, corresponding to parallel composition, otherwise.We then define a new translation function that takes the synchronization sets of an alt program into account and returns the corresponding set of cost equations.The translation of alt programs into the solver input code [2,8] has been prototyped and can be experimented (see Section 6). This tool, together with the compiler we have defined in [9], allows us to automatically compute the cost of programs in ABS, a prototype language for programming the cloud [13] that is an extension of alt. Experimental results show that our technique is very precise when computing the cost of a number of typical distributed patterns, such as fork-join or map-reduce.Paper overview. The alt language is defined in Section 2 and we discuss in Section 3 the issues in estimating the computational time. Section 4 explains the analysis of computational time by means of a translation function that returns cost equations, and Section 5 discusses the properties of the translation. In Section 6, we illustrate the ...

show abstract

Section: Related Workmentioning

confidence: 99%

Time analysis of actor programs

Laneve

Lienhardt

Pun

et al. 2019

Journal of Logical and Algebraic Methods in Programming

View full text Add to dashboard Cite

show abstract

“…to inform task scheduling. Trinder et al present a wide-ranging survey [34], and using their classification ACM is an abstract relative parallel cost model, based on heuristic linear equations, and parameterized by a parallel implementation model of the underlying hardware.…”

Section: Related Workmentioning

confidence: 99%

Pricing Python parallelism: a dynamic language cost model for heterogeneous platforms

Jacob

Trinder

Singer

2020

Proceedings of the 16th ACM SIGPLAN International Symposium on Dynamic Languages

View full text Add to dashboard Cite

Execution times may be reduced by offloading parallel loop nests to a GPU. Auto-parallelizing compilers are common for static languages, often using a cost model to determine when the GPU execution speed will outweigh the offload overheads. Nowadays scientific software is increasingly written in dynamic languages and would benefit from compute accelerators. The ALPyNA framework analyses moderately complex Python loop nests and automatically JIT compiles code for heterogeneous CPU and GPU architectures.We present the first analytical cost model for auto-parallelizing loop nests in a dynamic language on heterogeneous architectures. Predicting execution time in a language like Python is extremely challenging, since aspects like the element types, size of the iteration space, and amenability to parallelization can only be determined at runtime. Hence the cost model must be both staged, to combine compile and run-time information, and lightweight to minimize runtime overhead. GPU execution time prediction must account for factors like data transfer, block-structured execution, and starvation.We show that a comparatively simple, staged analytical model can accurately determine during execution when it is profitable to offload a loop nest. We evaluate our model on three heterogeneous platforms across 360 experiments with 12 loop-intensive Python benchmark programs. The results show small misprediction intervals and a mean slowdown of just 13.6%, relative to the optimal (oracular) offload strategy.CCS Concepts: • Software and its engineering → Dynamic compilers; Just-in-time compilers; • Computer systems organization → Heterogeneous (hybrid) systems.

show abstract

“…Predicting resource consumption of a software is crucial in parallel or distributed systems [48]. In this context, the main resources of interest to estimate are bounds for synchronisation costs, and execution and network transfer times.…”

Section: Cost Analysismentioning

confidence: 99%

“…Unlike simpler models, BSP recognises that synchronisation costs cannot be neglected, and that sharing data involves communication times, which depend on the infrastructure of the communication network, and the parallel and distributed processors under analysis. Interestingly, even when the model does not consider the processor internals, the memory hierarchy of specific communication patterns, it has been proved useful for predicting the true performance of applications [48,5].…”

Section: Cost Analysismentioning

confidence: 99%

A distributed approach for accelerating sparse matrix arithmetic operations for high-dimensional feature selection

et al. 2016

View full text Add to dashboard Cite

Matrix computations are both fundamental and ubiquitous in computational science, and as a result they are frequently used in numerous disciplines of scientific computing and engineering. Due to the highcomputational complexity of matrix operations, which makes them critical to the performance of a large number of applications, their efficient execution in distributed environments becomes a crucial issue. This work proposes a novel approach for distributing sparse-matrix arithmetic operations on computer clusters aiming at speeding-up the processing of high-dimensional matrices. The approach focuses on how to split such operations into independent parallel tasks by considering the intrinsic characteristics that distinguish each type of operation and the particular matrices involved. The approach was applied to the most commonly-used arithmetic operations between matrices. The performance of the presented approach was evaluated considering a high-dimensional text feature selection approach and two real-world datasets. Experimental evaluation showed that the proposed approach helped to significantly reduce the computing times of big-scale matrix operations, when compared to serial and multi-thread implementations as well as several linear-algebra software libraries.

show abstract

Resource analyses for parallel and distributed coordination

Cited by 11 publications

References 102 publications

Time analysis of actor programs

Time analysis of actor programs

Pricing Python parallelism: a dynamic language cost model for heterogeneous platforms

A distributed approach for accelerating sparse matrix arithmetic operations for high-dimensional feature selection

Contact Info

Product

Resources

About