Chunks and Tasks: A programming model for parallelization of dynamic algorithms

Rubensson, Emanuel H.; Rudberg, Elias

doi:10.1016/j.parco.2013.09.006

Cited by 18 publications

(18 citation statements)

References 34 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Distributed task frameworks that are based on, to some extent, other programming models are, e.g., Charm++ [17,18], which implements messagedriven execution, where the arrival of a data object prompts the execution of a task, and Chunks and Tasks [19], where chunks are immutable data objects that can be split hierarchically into smaller chunks, and tasks are objects that work on chunks, and can generate new tasks.…”

Section: Introductionmentioning

confidence: 99%

DuctTeip: An efficient programming model for distributed task-based parallel computing

2019

View full text Add to dashboard Cite

Current high-performance computer systems used for scientific computing typically combine shared memory computational nodes in a distributed memory environment. Extracting high performance from these complex systems requires tailored approaches. Task based parallel programming has been successful both in simplifying the programming and in exploiting the available hardware parallelism for shared memory systems. In this paper we focus on how to extend task parallel programming to distributed memory systems. We use a hierarchical decomposition of tasks and data in order to accommodate the different levels of hardware. We test the proposed programming model on two different applications, a Cholesky factorization, and a solver for the Shallow Water Equations. We also compare the performance of our implementation with that of other frameworks for distributed task parallel programming, and show that it is competitive. arXiv:1801.03578v1 [cs.DC] 10 Jan 2018 to the computational work performed by one node, the 1×9 process grid has the smallest variance between nodes, and therefore also the lowest maximum work size. The 9 × 1 process grid leads to smaller maximum work size than the 3 × 3 process grid if B is large enough, but suffers from significant load imbalance in the case B = 18. In all cases, the work becomes more evenly distributed if the number of level 1 tasks B is larger. The statistics for communication and computation point in different directions, but when comparing with actual run times, we have found that the communication size is the most informative measure. Having a large total communication size is likely to be detrimental to performance as the risk of tasks left waiting for remote data increases as well as the risk of congestion of messages. A square process grid is the factor that has the largest impact. Regarding the block sizes, having a large B improves the load balance, but increases the amount of communication as well as the number of messages (another indicator that is not shown in the graphics).

show abstract

Section: Introductionmentioning

confidence: 99%

DuctTeip: An efficient programming model for distributed task-based parallel computing

2019

View full text Add to dashboard Cite

show abstract

“…In the present work we use the Chunks and Tasks model as implemented in the proof-of-concept runtime library CHT-MPI, freely available for downloading at http://chunks-and-tasks.org/. The library is written in C++ and parallelized using MPI and Pthreads [24]. A work stealing approach is used to achieve load balancing.…”

Section: Chunks and Tasks Implementationmentioning

confidence: 99%

“…In this article we build on our previous work on a sparse matrix library based on sparse quaternary tree (quad-tree) matrix representation implemented using the Chunks and Tasks programming model [24,25]. The library is called the Chunks and Tasks Matrix Library (CHTML) and is publicly available at chunks-and-tasks.…”

mentioning

confidence: 99%

Parallelization and scalability analysis of inverse factorization using the chunks and tasks programming model

2019

Self Cite

View full text Add to dashboard Cite

We present three methods for distributed memory parallel inverse factorization of block-sparse Hermitian positive definite matrices. The three methods are a recursive variant of the AINV inverse Cholesky algorithm, iterative refinement, and localized inverse factorization, respectively. All three methods are implemented using the Chunks and Tasks programming model, building on the distributed sparse quad-tree matrix representation and parallel matrix-matrix multiplication in the publicly available Chunks and Tasks Matrix Library (CHTML). Although the algorithms are generally applicable, this work was mainly motivated by the need for efficient and scalable inverse factorization of the basis set overlap matrix in large scale electronic structure calculations. We perform various computational tests on overlap matrices for quasi-linear Glutamic Acid-Alanine molecules and three-dimensional water clusters discretized using the standard Gaussian basis set STO-3G with up to more than 10 million basis functions. We show that for such matrices the computational cost increases only linearly with system size for all the three methods. We show both theoretically and in numerical experiments that the methods based on iterative refinement and localized inverse factorization outperform previous parallel implementations in weak scaling tests where the system size is increased in direct proportion to the number of processes. We show also that compared to the method based on pure iterative refinement the localized inverse factorization requires much less communication.

show abstract

“…Asynchronous parallel programming is relatively new to scientific applications so we investigated two asynchronous task-based runtime systems, namely Intel Concurrent Collections CnC [5] and Charm++ [30], to schedule and execute SP2 subproblems. Detailed descriptions of CnC and Charm++ are found in Appendix A.…”

Section: Selection Of a Runtime Systemmentioning

confidence: 99%

“…The runtime system uses the partitioned graph to divide the SP2 calculation into independent dense matrix-matrix multiplication subproblems. These subproblems are assigned to processors using a task-based scheduler such as CnC [5] or Charm++ [30]. The resulting P is collected and sent back to the QMD application.…”

Section: Introductionmentioning

confidence: 99%

Task-based Parallel Computation of the Density Matrix in Quantum-based Molecular Dynamics using Graph Partitioning

Ghale¹,

Kroonblawd²,

Mniszewski³

et al. 2017

SIAM J. Sci. Comput.

View full text Add to dashboard Cite

Quantum-based molecular dynamics (QMD) is a highly accurate and transferable method for material science simulations. However, the time scales and system sizes accessible to QMD are typically limited to picoseconds and a few hundred atoms. These constraints arise due to expensive self-consistent ground-state electronic structure calculations that can often scale cubically with the number of atoms. Linearly scaling methods depend on computing the density matrix P from the Hamiltonian matrix H by exploiting the sparsity in both matrices. The second-order spectral projection (SP2) algorithm is an O(N ) algorithm that computes P with a sequence of 40 − 50 matrix-matrix multiplications. In this paper, we present task-based implementations of a recently developed data-parallel graph-based approach to the SP2 algorithm, G-SP2. We represent the density matrix P as an undirected graph and use graph partitioning techniques to divide the computation into smaller independent tasks. The partitions thus obtained are generally not of equal size and give rise to undesirable load imbalances in standard MPI -based implementations. This load-balancing challenge can be mitigated by dynamically scheduling parallel computations at runtime using task-based programming models. We develop task-based implementations of the data-parallel G-SP2 algorithm using both Intel's Concurrent Collections (CnC ) as well as the Charm++ programming model and evaluate these implementations for future use. Scaling and performance results of our implementations are investigated for representative segments of QMD simulations for solvated protein systems containing more than 10, 000 atoms.

show abstract

Chunks and Tasks: A programming model for parallelization of dynamic algorithms

Cited by 18 publications

References 34 publications

DuctTeip: An efficient programming model for distributed task-based parallel computing

DuctTeip: An efficient programming model for distributed task-based parallel computing

Parallelization and scalability analysis of inverse factorization using the chunks and tasks programming model

Task-based Parallel Computation of the Density Matrix in Quantum-based Molecular Dynamics using Graph Partitioning

Contact Info

Product

Resources

About