RRRuymán Reyes

Ruymán Reyes

*This is an algorithmically generated author record based on publicly available information.

Current Organizations / Institutes

The organizations/institutes from the scholar's latest article

Previous Organizations / Institutes

The organizations / institutes from the scholar's other articles in the past ten years


Ruymán Reyes has a total of 22 co-authors. Here are the top co-authors by number of shared publications:


Latest Publications

  • Open Access

    Leveraging task-parallelism in message-passing dense matrix factorizations using SMPSs

    by Alberto F. Martín, Ruymán Reyes, Rosa M. Badia, Enrique S. Quintana-Ortí


  • Performance Evaluation of OpenACC Compilers

    by Lucas Grillo, Ruyman Reyes, Francisco de Sande

    The OpenACC standard joint effort represents a step forward in the way of alleviating the programming effort when exploiting heterogeneous HPC using hardware accelerators. The lack of OpenACC annotated codes is a drawback for the adoption of the standard. Before real life OpenACC codes become available, benchmarking with synthetic codes is a useful tool to evaluate compilers and the OpenACC standard itself. In this work we use the recently published EPCC OpenACC benchmark suite to evaluate available OpenACC compilers from both industry and academia. We present computational result for the benchmark using both Fermi and Kepler NVIDIA architectures.


  • Programming for GPUs: The Directive-Based Approach

    by Lucas Grillo, Francisco De Sande, Juan J. Fumero, Ruyman Reyes

    In the last years, hardware accelerators, such as GPUs have become ubiquitous in the HPC landscape and GPGPU has been massively adopted by the HPC research community. If something is slowing down further expansion of this technology are its difficulties in terms of programmability. Although several libraries and applications providing GPU support are available, the need of implementing new algorithms from scratch, or adapting sequential programs to accelerators, still exist. Writing programs to be executed on accelerators is not easy, particularly for non-expert developers coming from the science or engineering fields, as it requires deep understanding of the underlying architecture. Different alternatives have appeared aimed to diminish the GPU programming effort. In the wake of the success of OpenMP, several directive-oriented programming models have been created. Although future OpenMP releases will integrate accelerators, tools are needed in the meantime. In this work, we present a comparison of directive-based approaches for GPU platforms, hiCUDA, PGI Accelerator and OpenACC. For the last, in addition to the two commercial compilers available, we include results using accULL, our own OpenACC implementation. To illustrate the portability of these alternatives, we show performance figures for both Fermi and Kepler NVIDIA cards.


  • Exploring large macromolecular functional motions on clusters of multicore processors

    by José R. López-Blanco, Ruymán Reyes, José I. Aliaga, Rosa M. Badia, Pablo Chacón, Enrique S. Quintana-Ortí


  • A preliminary evaluation of OpenACC implementations

    by Ruymán Reyes, Iván López, Juan J. Fumero, Francisco de Sande


  • Tools for Power-Energy Modelling and Analysis of Parallel Scientific Applications

    by Pedro Alonso, Rosa M. Badia, Jesus Labarta, Maria Barreda, Manuel F. Dolz, Rafael Mayo, Enrique S. Quintana-Orti, Ruym'N Reyes

    Understanding power usage in parallel workloads is crucial to develop the energy-aware software that will run in future Exascale systems. In this paper, we contribute towards this goal by introducing an integrated framework to profile, monitor, model and analyze power dissipation in parallel MPI and multi-threaded scientific applications. The framework includes an own-designed device to measure internal DC power consumption and a package offering a simple interface to interact with this design as well as commercial power meters. Combined with the instrumentation package Extrae and the graphical analysis tool Paraver, the result is a useful environment to identify sources of power inefficiency directly in the source application code. For task-parallel codes, we also offer a statistical software module that inspects the execution trace of the application to calculate the parameters of an accurate model for the global energy consumption, which can be then decomposed into the average power usage per task or the nodal power dissipated per core.


  • accULL: An User-directed Approach to Heterogeneous Programming

    by Ruym'N Reyes, Iv'N Lopez, Juan J. Fumero, Francisco de Sande

    The world of HPC is undergoing rapid changes and computer architectures capable to achieve high performance have broadened. The irruption in the scene of computational accelerators, like GPUs, is increasing performance while maintaining low cost per GFLOP, thus expanding the popularity of HPC. However, it is still difficult to exploit the new complex processor hierarchies. To adapt the message passing model to program heterogeneous CPU+GPUs environments is not an easy task. Furthermore, message passing does not seem to be the best choice from the programmer point of view. Traditional shared memory approaches like OpenMP are interesting to ease the popularization of these platforms, but the fact is that GPU devices are connected to the CPU through a bus and have a separate memory space. We need to find a way to deal with this issue at programming language level, otherwise, developers will spend most of their time focusing on low-level code details instead of algorithmic enhancements. The recent advent of the OpenACC standard for heterogeneous computing represents an effort in the direction of leveraging the development effort. This initiative, combined with future releases of the OpenMP standard, will converge into a fully heterogeneous framework that will cope the programming requirements of future computer architectures. In this work we present preliminary results of accULL, a novel implementation of the OpenACC standard, based on a source-to-source compiler and a runtime library. To our knowledge, our approach is the first providing support for both OpenCL and CUDA platforms under this new standard.


  • Binding Performance and Power of Dense Linear Algebra Operations

    by Maria Barreda, Manuel F. Dolz, Rafael Mayo, Enrique S. Quintana-Orti, Ruym'N Reyes

    In this paper we combine a powerful tracing framework with a power measurement setup to perform a visual analysis of the computational performance and the power consumption of tuned implementations for three key dense linear algebra operations: the LU factorization, the Cholesky factorization, and the reduction to tridiagonal form. Our results using 6 and 12 cores of an AMD Opteron-based platform reveal the serial/concurrent phases of the algorithms, and their connection to periods of low/high power consumption, as well as the linear dependency between execution time and energy for this class of operations.


  • Directive-based Programming for GPUs: A Comparative Study

    by Ruym'N Reyes, Ivan Lopez, Juan J. Fumero, Francisco de Sande

    GPUs and other accelerators are available on many different devices, while GPGPU has been massively adopted by the HPC research community. Although a plethora of libraries and applications providing GPU support are available, the need of implementing new algorithms from scratch, or adapting sequential programs to accelerators, will always exist. Writing CUDA or OpenCL codes, although an easier task than using their predecessors, is not trivial. Obtaining performance is even harder, as it requires deep understanding of the underlying architecture. Some efforts have been directed toward the automatic code generation for GPU devices, with different results. In particular, several directive-oriented programming models, taking advantage of the OpenMP success, have been created. Although future OpenMP releases will integrate accelerators into the standard, tools are needed in the meantime. In this work, we present a comparison between three directive-based programming models: hiCUDA, PGI Accelerator and OpenACC, using for the last our novel accULL implementation. With this comparison, we aim to showcase the evolution of the directive-based programming models and how users can guide tools toward better performance results.