Efficient scheduling of Virtual Power Plants (VPPs) is critical for integrating distributed energy resources into modern power systems. This paper introduces a CUDA-accelerated simulated annealing algorithm designed to optimize VPP scheduling by leveraging GPUs’ massive parallel processing capabilities. The proposed method reformulates the traditional simulated annealing process to exploit GPU parallelism, significantly reducing computational runtime and enhancing scalability even as the system dimensionality increases. Experimental results indicate that the GPU-based implementation maintains a consistent solution time irrespective of the number of prosumers, demonstrating robust performance in large-scale, real-world energy optimization scenarios. The findings suggest that CUDA-accelerated simulated annealing can serve as a highly effective tool for optimal VPP scheduling, offering substantial improvements in both efficiency and scalability.

Summary This paper presents a framework that enables the development of Java applications that execute on CPUs, graphics processing units (GPUs) and clusters of CPUs/GPUs. Applications are specified in an OpenMP‐like fashion, accessing data through a framework‐provided data API. The framework enables the efficient execution of applications in CPU and/or GPU by relying on two key features: (i) parallelism exploitation patterns are specified by additional aspect modules; and (ii) data layout can be selected according to the target platform. This paper describes how the framework abstractions are mapped and how the framework intrinsically supports the development of applications with hybrid parallelism by composing aspect modules with a given base program. Performance results show that the framework provides a performance level similar to traditional approaches and enables better performance portability for a given base program. Copyright © 2015 John Wiley & Sons, Ltd.

Phylogenetic inference is one of the most challenging and important problems in computational biology. However, computing evolutionary links on data sets containing only few thousands of taxa easily becomes a daunting task. Moreover, recent advances in next-generation sequencing technologies are turning this problem even much harder, either in terms of complexity or scale. Therefore, phylogenetic inference requires new algorithms and methods to handle the unprecedented growth of biological data. In this paper, we identify several types of parallelism that are available while refining a supertree. We also present four improvements that we made to SuperFine - a state-of-the-art supertree (meta)method -, which add support: i) to use FastTree as the inference tool; ii) to use a parallel version of FastTree, or RAxML, as the inference tool; iii) to exploit intra-polytomy parallelism within the so-called polytomy refinement phase; and iv) to exploit, at the same time, inter-polytomy and intra-polytomy parallelism within the polytomy refinement phase. Together, these improvements allow an efficient and transparent exploitation of hybrid-polytomy parallelism. Additionally, we pinpoint how future contributions should enhance the performance of such applications. Our studies show groundbreaking results in terms of the achieved speedups, specially when using biological data sets. Moreover, we show that the new parallel strategy - which exploits the hybrid-polytomy parallelism within the polytomy refinement phase - exhibits good scalability, even in the presence of asymmetric sets of tasks. Furthermore, the achieved results show that the radical improvement in performance does not impair tree accuracy, which is a key issue in phylogenetic inferences.

This paper introduces an aspect-oriented library aimed to support efficient execution of Java applications on multi-core systems. The library is coded in AspectJ and provides a set of parallel programming abstractions that mimics the OpenMP standard. The library supports the migration of sequential Java codes to multi-core machines with minor changes to the base code, intrinsically supports the sequential semantics of OpenMP and provides improved integration with object-oriented mechanisms. The aspect-oriented nature of library enables the encapsulation of parallelism-related code into well-defined modules. The approach makes the parallelisation and the maintenance of large-scale Java applications more manageable. Furthermore, the library can be used with plain Java annotations and can be easily extended with application-specific mechanisms in order to tune application performance. The library has a competitive performance, in comparison with traditional parallel programming in Java, and enhances programmability, since it allows an independent development of parallelism-related code.

One key issue to design parallel applications that scale on multicore systems is how to overcome the memory bottleneck. This paper presents a study of the impact of data structure layouts in locality of memory references, providing insights on strategies to ameliorate the memory bottleneck. The paper compares the performance of Java and C++ STL collections and presents the impact of locality of reference optimisations in a molecular dynamics simulation case study. The case study shows that the selected data structure layout has impact on single core performance, becoming a critical factor in the application scalability on multicore systems. Moreover, data collections provided in the Java language compromise performance due to pointer chasing and lack of spatial locality of memory references.

Enabling applications for computational Grids requires new approaches to develop applications that can effectively cope with resource volatility. Applications must be resilient to resource faults, adapting the behaviour to available resources. This paper describes an approach to application-level adaptation that efficiently supports application-level check pointing. The key of this work is the concept of pluggable parallelisation, which localises parallelisation issues into multiple modules that can be (un)plugged to match resource availability. This paper shows how pluggable parallelisation can be extended to effectively support check pointing and run-time adaptation. We present the developed pluggable mechanism that helps the programmer to include check pointing in the base (sequential). Based on these mechanisms and on previous work on pluggable parallelisation, our approach is able to automatically add support for check pointing in parallel execution environments. Moreover, applications can adapt from a sequential execution to a multi-cluster configuration. Adaptation can be performed by check pointing the application and restarting on a different mode or can be performed during run-time. Pluggable parallelisation intrinsically promotes the separation of software functionality from fault-tolerance and adaptation issues facilitating their analysis and evolution. The work presented in this paper reinforces this idea by showing the feasibility of the approach and performance benefits that can be achieved.

Current wide availability of multicore systems requires tools that can help scientists to smoothly update their applications to take advantage of the parallel processing capabilities of these systems. In this paper, we present an experience with aspect-oriented programming (AOP) techniques to perform this move. We describe the parallelization of a Java library that implements algorithms from the Evolutionary Computation field (JECoLi), applied to two case studies in Bioinformatics, namely the optimization of feeding profiles in fed-batch fermentations and in silico strain optimization in Metabolic Engineering. AOP allowed us to enable the library to take advantage of multicore systems with minimal impact on the original code and to simultaneously develop the parallelization and the original library. Moreover, we developed modules that extend the library’s behavior for a better usage of multicore resources. Performance results show that this approach boosts performance, does not compromise the quality of the final solutions and enables a more loosely coupled development.

This paper presents the concept of pluggable parallelisation that allows scientists to develop sequential like codes that can take advantage of multi-core, cluster and grid systems. In this approach parallel applications are developed by plugging parallelisation patterns/idioms into scientific codes (e.g., sequential like codes), softening the move from sequential to parallel programming and promoting the separation between domain specific code and parallelisation issues. Pluggable parallelisation combines three characteristics: 1) parallelisation is performed from outside to inside, localising parallelisation concerns into well defined modules, reducing changes required to the domain specific code and avoiding invasive parallelisation of base code; 2) control view is separated from data view promoting a stronger separation of concerns which improves reuse of parallelisation concerns across platforms and enables fine-grained refinements; and 3) abstractions can be composed, supporting the development of more complex patterns based on fine-grained features. This paper presents the concept of pluggable parallelisation and shows how some well known parallelisation strategies can be implemented in this approach. Results show that this is a feasible approach and performance is competitive with traditional parallel programming.

This paper describes how to improve separation between domain-specific code and parallel code in skeletal systems. Traditionally, the code used to exploit parallelism is tangled among domain-specific code, which leads to problems such as: poor maintainability, lower flexibility, and weak scalability. In this paper we introduce the design of the YaSkel framework, which is a support tool to write parallel programs. We argue that the design of YaSkel framework allows more freedom to change the parallelization strategy when compared with traditional skeleton frameworks. To change the parallelization strategy we rely on DI - Dependency Injection - to inject a reference of a specific skeleton in latter development stages. We also show that AOP - Aspect Oriented Programming - could be used to minimize the impact of applying skeleton based approaches to legacy code.

JaSkel is a skeleton-based framework to develop efficient concurrent, parallel and Grid applications. It provides a set of Java abstract classes that implement recurring parallel interaction paradigms. The key feature of JaSkel is to use aspect-oriented external tools to address distributed execution, by injecting code to support communication middleware into JaSkel built-in skeleton implementations. This feature, when combined with the ability to develop nested skeletons, can help to tailor JaSkel applications to efficiently run on a grid of clusters systems, by taking advantage of inter/intra-cluster and/or intra-node communications. This paper describes the JaSkel distributed execution tools and how they interplay with the JaSkel framework to transparently run applications on a wide range of computing platforms, from multi-core to computational grids. Results are presented to show the feasibility and scalability of this approach.

This paper presents a programming language for parallel computing based on code annotations. It has similar goals and philosophy as OpenMP but it is more tightly coupled to the object oriented paradigm. We include annotations for most common concurrency patterns and mechanisms, namely, one-way, futures, barriers, reads/writers and thread-local. Our current prototype is implemented using Java 5 annotations and AspectJ and provides a feasible and efficient alternative to the Java thread model

This paper presents JaSkel, a skeleton-based framework to develop parallel and grid applications. The framework provides a set of Java abstract classes as a skeleton catalogue, which implements recurring parallel interaction paradigms. This approach aims to improve code efficiency and portability. It also helps to structure scalable applications through the refinement and composition of skeletons. Evaluation results show that using the provided skeletons do contribute to improve both application development time and execution performance.

This paper presents a methodology to develop more modular parallel applications, based on aspect oriented programming. Traditional object oriented mechanisms implement application core functionality and parallelisation concerns are plugged by aspect oriented mechanisms. Parallelisation concerns are separated into four categories: functional or/and data partition, concurrency, distribution and optimisation. Modularising these categories into separate modules using aspect oriented programming enables (un)pluggability of parallelisation concerns. This approach leads to more incremental application development, easier debugging and increased reuse of core functionality and parallel code, when compared with traditional object oriented approaches. A detailed analysis of a simple parallel application - a prime number sieve - illustrates the methodology and shows how to accomplish these gains.

This paper presents a new approach to texture defect detection based on a set of optimised filters. Each filter is applied to one wavelet sub-band and its size and shape are tuned for a defect type. The wavelet transform provides a very efficient way to decompose a complex texture into a set of base components (wavelet sub-bands), which are then analysed by each filter to detect a kind of defect. The proposed methodology has been successfully applied to leather inspection, achieving the detection rate of highly trained human operators. The process is also fast enough to be used for in-line inspection.