Eloy Romero

Elastic Memory Management of Virtualized Infrastructures for Applications with Dynamic Memory Requirements

Abstract This paper addresses the impact of vertical elasticity for applications with dynamic memory requirements when running on a virtualized environment. Vertical elasticity is the ability to scale up and scale down the capabilities of a Virtual Machine (VM). In particular, we focus on dynamic memory management to automatically fit at runtime the underlying computing in- frastructure to the application, thus adapting the memory size of the VM to the memory consumption pattern of the application. An architecture is described, together with a proof-of-concept implementation, that dynamically adapts the memory size of the VM to prevent thrashing while reducing the excess of unused VM memory. For the test case, a synthetic benchmark is em- ployed that reproduces different memory consumption patterns that arise on real scientific applications. The results show that vertical elasticity, in the shape of dynamic memory management, enables to mitigate memory overprovisioning with controlled application performance penalty.

Multi-dimensional gyrokinetic parameter studies based on eigenvalue computations

Abstract Plasma microinstabilities, which can be described in the framework of the linear gyrokinetic equations, are routinely computed in the context of stability analyses and transport predictions for magnetic confinement fusion experiments. The GENE code, which solves the gyrokinetic equations, has been coupled to the SLEPc package for an efficient iterative, matrix-free, and parallel computation of rightmost eigenvalues. This setup is presented, including the preconditioner which is necessary for the newly implemented Jacobi–Davidson solver. The fast computation of instabilities at a single parameter set is exploited to make parameter scans viable, that is to compute the solution at many points in the parameter space. Several issues related to parameter scans are discussed, such as an efficient parallelization over parameter sets and subspace recycling.

CodeCloud: A Platform to Enable Execution of Programming Models on the Clouds

This paper presents a platform that supports the execution of scientic applications covering dierent programming models (such as Master/Slave, Parallel/MPI, MapReduce and Workows) on Cloud infrastructures. The platform includes i) a high-level declarative language to express the requirements of the applications featuring software customization at runtime; ii) an approach based on virtual containers to encapsulate the logic of the dierent programming models; iii) an infrastructure manager to interact with dierent IaaS backends; iv) a conguration software to dynamically congure the provisioned resources and v) a catalog and repository of virtual machine images. By using this platform, an application developer can adapt, deploy and execute parallel applications agnostic to the cloud backend.

Self-managed cost-efficient virtual elastic clusters on hybrid Cloud infrastructures

In this study, we describe the ?further development of Elastic Cloud Computing Cluster (EC3), a tool ?for creating self-managed cost-efficient virtual hybrid elastic clusters on top of Infrastructure as a Service (IaaS) clouds. By using spot ?instances and checkpointing techniques, EC3 can significantly reduce the total ?execution cost as well as facilitating automatic fault tolerance. Moreover, EC3 can deploy and manage hybrid clusters across on-premises and public ?cloud resources, thereby introducing ?cloud bursting capabilities. ?We present the results of a case study that we conducted to assess the effectiveness of the tool ?based on the structural dynamic analysis of buildings. In addition, we evaluated the checkpointing algorithms in a real ?cloud environment with existing workloads to study their effectiveness. The results ?demonstrate the feasibility and benefits of this type of ?cluster for computationally intensive applications. Cost-efficient hybrid elastic virtual clusters are deployed across clouds.Spot instances and checkpointing reduce the costs of execution.Hybrid clusters reduce the total execution time by employing cloud bursting.Computationally intensive applications are executed easily with EC3.

A parallel implementation of Davidson methods for large-scale eigenvalue problems in SLEPc

In the context of large-scale eigenvalue problems, methods of Davidson type such as Jacobi-Davidson can be competitive with respect to other types of algorithms, especially in some particularly difficult situations such as computing interior eigenvalues or when matrix factorization is prohibitive or highly inefficient. However, these types of methods are not generally available in the form of high-quality parallel implementations, especially for the case of non-Hermitian eigenproblems. We present our implementation of various Davidson-type methods in SLEPc, the Scalable Library for Eigenvalue Problem Computations. The solvers incorporate many algorithmic variants for subspace expansion and extraction, and cover a wide range of eigenproblems including standard and generalized, Hermitian and non-Hermitian, with either real or complex arithmetic. We provide performance results on a large battery of test problems.

Computing subdominant unstable modes of turbulent plasma with a parallel Jacobi–Davidson eigensolver

In the numerical solution of large‐scale eigenvalue problems, Davidson‐type methods are an increasingly popular alternative to Krylov eigensolvers. The main motivation is to avoid the expensive factorizations that are often needed by Krylov solvers when the problem is generalized or interior eigenvalues are desired. In Davidson‐type methods, the factorization is replaced by iterative linear solvers that can be accelerated by a smart preconditioner. Jacobi–Davidson is one of the most effective variants. However, parallel implementations of this method are not widely available, particularly for non‐symmetric problems. We present a parallel implementation that has been included in SLEPc, the Scalable Library for Eigenvalue Problem Computations, and test it in the context of a highly scalable plasma turbulence simulation code. We analyze its parallel efficiency and compare it with a Krylov–Schur eigensolver. Copyright

Parallel finite element density functional computations exploiting grid refinement and subspace recycling

In this communication computational methods that facilitate finite element analysis of density functional computations are developed. They are: (i) h‐adaptive grid refinement techniques that reduce the total number of degrees of freedom in the real space grid while improving on the approximate resolution of the wanted solution; and (ii) subspace recycling of the approximate solution in self-consistent cycles with the aim of improving the performance of the generalized eigenproblem solver. These techniques are shown to give a convincing speed-up in the computation process by alleviating the overhead normally associated with computing systems with many degrees-of-freedom.

A Parallel implementation of the Jacobi-Davidson eigensolver and its application in a plasma turbulence code

In the numerical solution of large-scale eigenvalue problems, Davidson-type methods are an increasingly popular alternative to Krylov eigensolvers. The main motivation is to avoid the expensive factorizations that are often needed by Krylov solvers when the problem is generalized or interior eigenvalues are desired. In Davidson-type methods, the factorization is replaced by iterative linear solvers that can be accelerated by a smart preconditioner. Jacobi-Davidson is one of the most effective variants. However, parallel implementations of this method are not widely available, particularly for non-symmetric problems. We present a parallel implementation to be released in SLEPc, the Scalable Library for Eigenvalue Problem Computations, and test it in the context of a highly scalable plasma turbulence simulation code. We analyze its parallel efficiency and compare it with Krylov-type eigensolvers.

A Fast Sparse Block Circulant Matrix Vector Product

In the context of computed tomography (CT), iterative image reconstruction techniques are gaining attention because high-quality images are becoming computationally feasible. They involve the solution of large systems of equations, whose cost is dominated by the sparse matrix vector product (SpMV). Our work considers the case of the sparse matrices being block circulant, which arises when taking advantage of the rotational symmetry in the tomographic system. Besides the straightforward storage saving, we exploit the circulant structure to rewrite the poor-performance SpMVs into a high-performance product between sparse and dense matrices. This paper describes the implementations developed for multi-core CPUs and GPUs, and presents experimental results with typical CT matrices. The presented approach is up to ten times faster than without exploiting the circulant structure.

A parallel implementation of the Jacobi-Davidson eigensolver for unsymmetric matrices

This paper describes a parallel implementation of the Jacobi-Davidson method to compute eigenpairs of large unsymmetric matrices. Taking advantage of the capabilities of the PETSc library --Portable Extensible Toolkit for Scientific Computation--, we build an efficient and robust code adapted either for traditional serial computation or parallel computing environments. Particular emphasis is given to the description of some implementation details of the so-called correction equation, responsible for the subspace expansion, and crucial in the Jacobi-Davidson algorithm. Numerical results are given and the performance of the code is analyzed in terms of serial and parallel efficiency. The developments achieved in the context of this work will be incorporated in future releases of SLEPc --Scalable Library for Eigenvalue Problem Computations--, thus serving the scientific community and guaranteeing dissemination.