Wildfires significantly impact natural ecosystems and human health, leading to biodiversity loss, increased hydrogeological risks, and elevated emissions of toxic substances. Climate change exacerbates these effects, particularly in regions with rising temperatures and prolonged dry periods, such as the Mediterranean. This requires the development of advanced risk management strategies that utilize state-of-the-art technologies. However, in this context, the data show a bias toward an imbalanced setting, where the incidence of wildfire events is significantly lower than typical situations. This imbalance, coupled with the inherent complexity of high-dimensional spatio-temporal data, poses significant challenges for training deep learning architectures. Moreover, since precise wildfire predictions depend mainly on weather data, finding a way to reduce computational costs to enable more frequent updates using the latest weather forecasts would be beneficial. This paper investigates how adopting a contrastive framework can address these challenges through enhanced latent representations for the patch’s dynamic features. We thus introduce a new morphology-based curriculum contrastive learning that mitigates issues associated with diverse regional characteristics and enables the use of smaller patch sizes without compromising performance. An experimental analysis is performed to validate the effectiveness of the proposed modeling strategies.

Cellular Automata (CA) are extensively utilized for modeling and simulating complex systems due to their simplicity, flexibility, and ability to represent diverse phenomena. However, the computational intensity of CA models, particularly in large-scale applications, demands the development of efficient parallel execution techniques. This is especially critical when targeting shared memory architectures, where resource management and thread coordination play pivotal roles in achieving optimal performance. In this study, we examine a range of parallel execution strategies specifically designed to enhance the efficiency and scalability of CA models. The experimental evaluation highlights good scalability in execution time and resource utilization, making these strategies highly suitable for extensive simulations across various domains. Additionally, the results emphasize that imbalance conditions—often arising during CA computations—can considerably influence the effectiveness of choosing a given strategy.

This work is focused on the transparent execution of Cellular Automata models on a multi-GPU architecture. Although Cellular Automata models can be easily parallelized on a single GPU, the domain size and transition function complexity may require the use of multiple GPUs. Our goal is to allow modellers to be completely unaware of the parallel execution context, i.e., the code implementing the Cellular Automata model remains the same regardless if the execution is performed on CPU, single GPU, or multi-GPU systems. This paper supplies meaningful technical insights on how to ensure both transparency and efficiency in multi-GPU execution of Cellular Automata models. In particular, an object-oriented approach is exploited in which a transparent layer is devised that abstracts the parallelization details and allows a strong “separation of concerns” between the execution parallelism issues and the model implementation. Preliminary experiments have been carried out on the multi-GPU cluster CTE-POWER available at the Barcelona Supercomputing Center (BSC), witnessing good speedups notwithstanding the transparency feature supplied by our approach.

Nowadays, performance in HPC applications focuses on MPI efficiency as the de facto message-passing library to exploit parallelism. Features such as multithread and communication and processing overlap are continuously studied to adapt to new platforms and a more significant number of processing units like GPU platforms. In this sense, recently, the MPI-4.0 standard introduced the partitioned point-to-point communication primitives to potentiate computation and communication overlapping. This paper introduces an innovative extension to MPI, specifically addressing partitioned communication for MPI-reduction primitives. Traditional reduction tasks conventionally involve processing the complete input vector following the conclusion of GPU computations. In contrast, our proposed methodology exploits message partitioning to process reduction tasks in real-time incrementally. This approach allows the system to process individual partitions of the input vector as they become available, removing the necessity to await the full completion of GPU computations before initiating the reduction. Our results demonstrate promising benefits, particularly for large message sizes. However, it is essential to acknowledge that optimizations at synchronization points remain potential bottlenecks, requiring meticulous analysis and consideration.

Cellular Automata (CA) models, initially studied by John von Neumann, have been developed by numerous researchers and applied in both academic and scientific fields. Thanks to their local and independent rules, simulations of complex systems can be easily implemented based on CA modelling on parallel machines. However, due to the heterogeneity of the components - from the hardware to the software perspective-the various possible scenarios running parallelism in today's architectures can pose a challenge in such implementations, making it difficult to exploit. This paper presents OpenCAL++, a transparent and efficient object-oriented platform for the parallel execution of cellular automata models. The architecture of OpenCAL++ ensures the modeller a fully transparent parallel execution and a strong “separation of concerns” between the execution parallelism issues and the model implementation. The code implementing the Cellular Automata model remains the same whether the execution performs in a shared-, distributed-memory or a GPGPU context, irrespective of the optimizations adopted. To this aim, the object-oriented paradigm has been intensely exploited. As well as the OpenCAL++ architecture, we present the description of a simple Cellular Automata model implementation for illustrative purposes.

We present the results of a performance assessment and optimisation work regarding the CUDA implementation of the three-dimensional XCA-Flow subsurface Extended Cellular Automata model. To this end, we have considered a ten days long simulation already considered in previous works, characterised by a constant infiltration rate and a heterogeneous hydraulic conductivity field, as the benchmark. We ran the experiments on the Nvidia V100 high-performance many-core device. We have analysed essential aspects of the XCA-Flow model by updating its kernels. We applied classical tiling/shared memory techniques to the stencil-based and reduction kernels in the first step. Results suggested applying a thorough analysis of the model. Both theoretical and experimental assessments have driven this analysis, which has pointed out the need to increase the achieved warp occupancy to speed up the computation. The resulting general redesign of the application allowed for a 20.3% mean performance gain (over the CUDA block configurations considered). We also performed two Roofline analyses to characterise the kernels of the original and improved implementations in terms of arithmetic intensity and performance. Besides the improved performance, we have obtained meaningful insights about the CUDA implementation of the XCA-Flow model that could, in principle, allow for further optimisations.

Modelling subsurface flow processes is one of the key factors to describe the water cycle. To this aim, a variably saturated flow model was developed based on the Extended Cellular Automata (XCA) formalism and used to simulate an ensemble of 100 synthetic two-dimensional plots with heterogeneous hydraulic properties. The model was implemented exploiting the functionalities of the OpenCAL library, which allowed high computational efficiency using multi-core (CPU) processors and even higher performances with many-core (GPGPU) architectures.

The allocation of the computational load across different processing elements is an important issue in parallel computing. Indeed, an unbalanced load distribution can strongly affect the performances of a parallel system caused by an excess of synchronization idle times due to less loaded processes waiting for more loaded ones. In this article, we focus on the load balancing issues in the context of the parallel execution of spatial-related applications where the domain space is partitioned in regions that are assigned to different processing elements. In particular, without loss of generality, we consider the well-known spatial-related Cellular Automata computational paradigm for evaluating the proposed dynamic load balancing approach. The main contribution of this article is the derivation of simple closed-form expressions that allow to compute the optimal workload assignment in a dynamic fashion, with the goal of guaranteeing a fully balanced workload distribution during the parallel execution. Based on these expressions, an algorithm for balanced execution of cellular automata is presented and implemented using the MPI technology. Eventually, an experimental section practically shows the behaviour of the proposed dynamic load balancing approach and proves its performance improvement, compared to the not-balanced version, as witnessed by the appreciable reduction of execution times.

Cellular Automata (CA) are parallel models well-suited for studying complex systems that are based on local rules of evolution. Notable examples of application are found in fluid-dynamics, crowd simulation, flow-simulation and many more. Nevertheless, CA can be fruitfully exploited as a support in numerical approaches, such as finite element and finite volume methods. Though easily parallelizable by domain partitioning among the nodes of a parallel system, the performance and scalability of cellular automata executed on parallel/distributed machines are limited due to the need of synchronizing nodes at each computational step. With the aim of reducing the synchronization burden, we here present a preliminary study on techniques stemmed from the Discrete-Event Simulation field for the optimization of CA on distributed memory architectures. Preliminary results, executed in a distributed memory environment, have shown the usefulness of the considered approach in reducing execution times and therefore in improving the speed up of the parallel execution of the test case.

The Cellular Automata paradigm is an efficient tool to model and study complex systems such as traffic simulation, lava flows and swarm based behaviour. In addition, cellular automata can be profitably used in many mathematical problems such as differential equations and chaos theory. Due to their inherent parallel nature, cellular automata can be efficiently parallelized among a set of computing nodes in order to scale and speed up their execution. This paper presents a preliminary study on different parallelization techniques for structured grid models such as cellular automata on distributed memory architectures. In particular, three strategies are presented and compared in order to evaluate their efficiency in terms of speedup. An experimental section shows the performance achieved by the three strategies when a real-life application, namely the SciddicaT cellular automata model for debris-flows simulation, is adopted.

Here we present different preliminary parallel grid-based implementations of a simple particle system with the purpose to evaluate its performances on multi- and many-core computational devices. The system is modeled by means of the Discrete Element Method and the Extended Cellular Automata formalism, while OpenMP and OpenCL are used for parallelization. In particular, both the 3.1 and 4.5 OpenMP specifications have been considered, the latter also able to run on many-core computational devices like GPUs. The results of a first test simulation performed by considering a cubic domain with about 316,000 particles have shown a clear advantage of OpenCL on the considered Tesla K40 Nvidia GPU, while the OpenMP 3.1 implementation has performed better than the corresponding OpenMP 4.5 on the considered Intel Xeon E5-2650 16-thread CPU.

The performance and scalability of cellular automata, when executed on parallel/distributed machines, are limited by the necessity of synchronizing all the nodes at each time step, i.e., a node can execute its code only after all the other nodes have executed the previous step. However, if the code is parallelized by partitioning the space of the automata, these synchronization requirements can be relaxed: indeed, a node that manages a given portion of the cellular automata can execute a new step after synchronizing only with the nodes that manage the adjacent portions, while the remaining nodes can execute different time steps. This can be a notable advantage in many novel and increasingly popular applications of cellular automata, such as smart city applications, simulation of natural phenomena, etc., in which the execution times can be different and variable, due to the heterogeneity of machines and/or of the data and/or of the different functions. Indeed, a longer execution time at a node does not slow down the execution at all the other nodes but only at the neighboring nodes. This is particularly advantageous when the nodes that act as a bottleneck can vary during the execution. The goal of the paper is to analyze the benefits that can be achieved with the described approach when different space partitioning strategies are taken into account: i.e., the mono-and the two-dimensional partitioning. Experiments referred to a well-known cellular automata, namely the SciddicaS3-hex model for landslide simulation, exhibit good scalability and prove that the partitioning scheme adopted can result crucial for improving the overall computational performances.

Particle tracking plays an important role in numerous fields of science. In this paper, we present TraCCA, an algorithm for detecting and tracking particles based on geometrical difference evaluation and centroid displacement analysis to reconstruct the trajectories. This method works for n-dimensional input data provided that particles are represented by at least a centroid space coordinate and a geometrical entity which describe their shape. Since 2-D images are a common source of such data, we also present a framework for image-manipulation based on Extended Cellular Automata (XCA). We have applied and validated TraCCA in investigating the motility of B. subtilis. injected in a microfluidic device using 4100 images taken at 100 frames per second. Results show that the framework is able to reconstruct the trajectories as computed motion parameters are in accordance with the ones reported in the literature.

Birds flocking is an interesting natural phenomenon to study as proven by numerous papers in this field. In this paper, we present a GPGPU model for birds flocking simulation using NVIDIA's CUDA framework. This technology has been widely adopted in computational science and have dramatically increased computation performances. Using the autonomous agent approach with multi-agents and multiple groups for birds flocking modeling, we present the ACIADDRI model both aggregate motion of a large number of birds in virtual environment and other species or predators avoidance in the plane as well. From these experiments we gained significant performance improvements in the terms of speedup. In conclusion, the work shows that the use of the CUDA technology can be effective to cut computational costs also in multi-agent modeling.

Cellular Automata represent a formal frame for dynamical systems which evolve on the base of local interactions. We here present first results of the CUDA parallelization of the SCIDDICA S3-hex Complex Cellular Automata model for simulating debris flows. In particular, a first strategy for the parallelization of the model is based on a straightforward one thread - one cell approach, where each cell in the cellular space is computed by a CUDA thread. A second approach concerns the adoption of a list of CA computational active cells which is handled step by step by an efficient stream compaction algorithm, in order to reduce the excessive use of computationally inactive threads. First results performed on different graphic processors have shown that, by adopting the different CUDA strategies, this kind of hardware can be effective for landslide risk mitigation.

This paper presents the release fv3 of the Complex Cellular Automata model Sciara for simulating lava flows. It is based on a Bingham-like rheology and both flow velocity and the physical time corresponding to a computational step have been made explicit. The model has been preliminary tested with satisfying results by considering the 2006 lava event at Mt Etna (Italy). A HTML5 based Web application with a WebGL 3D interactive visualization system has also been developed as user interface for Sciara-fv3. Eventually, the numerical code has been parallelised by the CUDA GPGPU paradigm, allowing for a considerable reduction of the execution time, despite the numerical code complexity.