Enrique Soler

SBASCO: skeleton-based scientific components

SBASCO is a new programming environment for the development of parallel and distributed high-performance scientific applications. The approach integrates both skeleton-based and component technologies. The main goal of the proposal is to provide a high-level programmability system for the efficient development of numerical applications with performance portability on different platforms. We present the system programming model which considers two different views of a component interface: one from the point of view of the application programmer and another thought to be used by a configuration tool in order to establish efficient implementations. This can be achieved due to the knowledge at the interface level of data distribution and processor layout inside each component. The programming model borrows from software skeletons a cost model enhanced by a run-time analysis, which enables one to automatically establish a suitable degree of parallelism and replication of the internal structure of a component.

Domain decomposition techniques for reaction-diffusion equations in two-dimensional regions with re-entrant corners

A system of two non-linear reaction-diffusion equations is solved numerically by means of linearized @q-methods and both overlapping and non-overlapping domain decomposition techniques in two-dimensional regions with re-entrant corners. Two numerical methods based on either approximate factorization (AF) or the bi-conjugate-gradient-stabilized (BiCGstab) technique are employed. A study of the effects of the number of overlapping grid lines on both the accuracy and numerical efficiency is presented. For non-overlapping domain decomposition techniques, the unknown values at the common interface between adjacent subdomains have been updated by means of Dirichlet, Neumann and Robin couplings, and combinations thereof. It is shown that non-overlapping domain techniques are less accurate than overlapping ones for domains with re-entrant corners because the interfaces between adjacent subdomains are evaluated by imposing continuity of the unknowns and their normal derivatives there, and, therefore, the partial differential equations are not solved at the interfaces between adjacent subdomains. Nevertheless, the accuracy of these techniques increases as the grid spacing is decreased, although they still exhibit large errors near the re-entrant corners.

A Border-based Coordination Language for Integrating Task and Data Parallelism

This paper presents BCL, a border-based coordination language focused on the solution of numerical applications. Our approach provides a simple parallelism model. Coordination and computational aspects are clearly separated. The former are established using the coordination language and the latter are coded using HPF (together with only a few extensions related to coordination). This way, we have a coordinator process that is in charge of both creating the different HPF tasks and establishing the communication and synchronization scheme among them. In the coordination part, processor and data layouts are also specified. Data distribution belonging to the different HPF tasks is known at the coordination level. This is the key for an efficient implementation of the communication among them. Besides that, our system implementation requires no change to the runtime support of the underlying HPF compiler. By means of some examples, the suitability and expressiveness of the language are shown. Some experimental results also demonstrate the efficiency of the model.

Domain interaction patterns to coordinate HPF tasks

This paper describes domain interaction patterns, a pattern-based, high level coordination language, which provides a new way of integrating task and data parallelism. Coordination patterns are used to express task parallelism among a collection of data parallel High Performance Fortran (HPF) tasks. Patterns specify the interaction among domains involved in the application along with the processor and data layouts. The use of domains, i.e. regions together with some interaction information, improves pattern reusability. Data distribution belonging to the different HPF tasks is known at the coordination level. This is the key for both computational code reutilization and an efficient implementation of the communication among tasks. Besides that, our system implementation requires no change to the runtime system support of the HPF compiler used. In addition, a set of different implementation templates is provided in order to ease the programmer task. The suitability, expressiveness and efficiency of the language are shown by means of some examples.

An aspect oriented framework for scientific component development

Aspect-oriented programming enables developers to capture in separated aspect modules concerns that are spread over different components in a system. This paper is an attempt to apply this paradigm to high performance computing. Besides achieving the usual advantages of improved modularity, more reusable code that is easier to develop and maintain, we pursue to improve efficiency by means of dynamic changes of aspects at runtime. We present an aspect-oriented framework where scientific components and aspects are first-order entities (components) which interaction is established by means of what we have called aspect connectors. As an example, we focus on the communication aspect, which encapsulates the communication scheme among the set of components that set up a system. The expressiveness and suitability of the approach are shown by means of an application example.

On blockchain and its integration with IoT. Challenges and opportunities

Abstract In the Internet of Things (IoT) vision, conventional devices become smart and autonomous. This vision is turning into a reality thanks to advances in technology, but there are still challenges to address, particularly in the security domain e.g., data reliability. Taking into account the predicted evolution of the IoT in the coming years, it is necessary to provide confidence in this huge incoming information source. Blockchain has emerged as a key technology that will transform the way in which we share information. Building trust in distributed environments without the need for authorities is a technological advance that has the potential to change many industries, the IoT among them. Disruptive technologies such as big data and cloud computing have been leveraged by IoT to overcome its limitations since its conception, and we think blockchain will be one of the next ones. This paper focuses on this relationship, investigates challenges in blockchain IoT applications, and surveys the most relevant work in order to analyze how blockchain could potentially improve the IoT.

Adding Aspect-Oriented Concepts to the High-Performance Component Model of SBASCO

SBASCO provides a new programming model for parallel and distributed numerical applications which exploits the combination of software components and skeletons. This paper presents an extension to both the model and implementation of SBASCO, so that the notion of aspect is applied in conjunction with the original paradigms. The objective is to achieve a higher level of modularity and reuse in parallel scientific codes and applications. Our aspects are managed as components which implement the (sequential or parallel) cross-cutting functionality. Aspects interact with the base code by means of connectors that express the cross-cutting nature of the target concerns. The way in which both aspect weaving and advice code execution are managed is critical for preserving the performance of applications. An implementation of the abstractions for distributed memory parallel systems based on MPI is discussed.

A component‐based nuclear power plant simulator kernel

This paper presents a nuclear power plant simulator kernel based on the high‐performance computing‐oriented Common Component Architecture (CCA). The approach takes advantage of both the component‐based software development and the efficient execution of parallel simulation models. The use of components improves the software life cycle and facilitates the development, maintenance and evolution of the simulator kernel, which can be adapted to different execution scenarios. Data dependencies among simulation models are resolved automatically by means of a novel algorithm, releasing the programmer from this tedious task and, as a result, making the development process easier. This work introduces the main features of the simulator kernel, describing concepts and the model on which it is based. Some preliminary results are shown that anticipate the feasibility and suitability of the proposal. Copyright

Using SBASCO to solve reaction-diffusion equations in two-dimensional irregular domains

The SBASCO programming environment provides the developer of parallel and distributed applications with high-level programming capabilities. This is achieved as a result of the combination of two technologies: algorithmic skeletons and software components. This paper is a case study on the use of SBASCO. Specifically, we present a scientific application to study the propagation of reaction waves in two-dimensional irregular domains which can be divided into overlapping rectangular regions. Domain decomposition techniques are used to solve a system of two non-linear reaction-diffusion equations. The structure of the application is established by means of a high-level skeleton, which captures all the communication and synchronization details that take place in parallel component interaction, thereby releasing the programmer from coding them. In addition, the use of software components facilitates the development process and allows the creation of more flexible and adaptable software.

A CCA-compliant nuclear power plant simulator kernel

This paper presents a parallel, component-oriented nuclear power plant simulator kernel. It is based on the high-performance computing oriented Common Component Architecture. The approach takes advantage of both the component paradigm and the parallel execution of simulation models. This way, the maintenance, evolution and efficiency of a simulator are improved. The work introduces the main features of the simulator kernel, describing concepts and the model it is based on. Data dependencies among components (simulation models conforming a simulator) are solved in a configuration phase, reducing the execution time of the simulation phase. Some preliminary results are shown, which anticipate the feasibility, suitability and efficiency of the proposal.