Parallel And Distributed Simulation (PADS) is a well-known modeling paradigm that allows for efficient implementation of large simulation models as a collection of interacting entities, called Simulated Entities (SEs). SEs can then be assigned to independent execution units for parallel execution, if possible. Allocating SEs to execution units is one of the most challenging problems in PADS: ideally, highly interacting SEs should be placed on the same execution unit so that all communications are local; however, placing too many SEs on the same processor might degrade performance. Furthermore, many simulation models exhibit non-uniform computation and communication patterns among components, that might change during execution at unpredictable times. In this paper we propose a clustering heuristic that exploits communication locality, with the aim to reduce the communication cost experienced by the PADS during the execution. The heuristic adapts automatically to changing interaction patterns by migrating SEs, and can do so without any user-visible modification of the simulation model; there are, however, some parameters that can be used to tune the heuristic. We perform a large set of computational experiments to assess the effectiveness of the heuristic on a real-world scenario, with the aim of guiding the users in selecting optimal values of the heuristic parameters.

We present an experience report on an industrial feasibility study that evaluates the application of code LLM technologies within an organization, ensuring that no data leaves the firm’s perimeter. To address a set of feasibility questions, we employed state-of-the-art techniques, including Low-Rank Adaptation (LoRA), Parameter-Efficient Fine-Tuning (PEFT), and 4-bit quantization, to develop a pipeline for creating a fine-tuned version of an existing code LLM that is small enough to allow both training and inference on commodity hardware, thereby eliminating the need for cloud-based solutions that would expose sensitive assets, such as parts of the existing code base, outside the firm’s local network. We evaluated the pipeline on a general programming language (namely Python) to assess its performance, and our results show that it is adequate for the task at hand. Other than concerns about data privacy, another motivation for this study stems from the firm’s adoption of a domain-specific programming language, which is not directly supported by most existing code LLMs. However, we believe that the lessons we learned in this experience could be valuable in many other contexts where a firm is evaluating the feasibility of an in-house AI-based solution rather than depending on external service providers.

The rise of blockchain has expanded the possibilities for asset representation, particularly through Non-Fungible Tokens (NFTs), which enable unique connections between digital and physical assets. Despite their potential, existing NFT systems face challenges such as high transaction costs and uncertainties related to the management and transfer of associated physical assets. This paper introduces a decentralized marketplace architecture designed to address these challenges, by making use of blockchain-based smart contracts, decentralized storage solutions, and trustless validation mechanisms. The proposed system separates ownership from possession, ensuring secure and transparent asset transfers. The architecture was then tested in a blockchain-based environment, demonstrating its economic viability. This work paves the way for decentralized asset management across various domains, such as rental services and remote logistics. By addressing existing challenges, the proposed architecture provides a usable and cost-effective solution that links digital and physical asset ecosystems while preserving the fundamental principles of blockchain technology.

Mini-applications are widely used in parallel computing for testing and benchmarking purposes. However, many existing mini-applications are not suitable for teaching, since they require advanced knowledge of algebra, numerical analysis or physics to be fully understood, which might be beyond the reach of beginners. In this paper we describe a set of programming assignments, called parallel etudes, that have been used in the last years for teaching High Performance Computing at the undergraduate level. These applications are self-contained, self-documenting, and short. They are drawn from more familiar domains such as 3D rendering, simulation, image processing and simple physics models, to be more accessible to students without a strong mathematical background. The mini-applications target shared-memory, distributed-memory and GPU programming. The analysis of the students’ feedback and final grades provides indirect support for the effectiveness of the etudes.

Removing noise in digital images is a fundamental operation that arises in many application domains. In this paper we consider the median filter, a filtering technique that replaces the color of each pixel with the median of those in a square neighborhood of fixed radius. For some use cases, the size of the neighborhood or the image depth may be large, making existing algorithms either too slow, or not applicable at all due to excessive memory requirements. In this paper we describe architecture-specific optimizations that enable the computation of the median filter with arbitrary window size and image depth on multicore processors and GPUs. We report preliminary results that indicate that the parallel implementations are suitable for practical use, with the GPU version outperforming the CPU.

Multilevel modeling is a design technique that allows complex models to be specified in terms of simpler ones. An obvious advantage of multilevel modeling is the possibility of reusing existing models, therefore reducing development cost. However, multilevel modeling entails more than the mere application of the ubiquitous principle of decomposition. Indeed, in a multilevel model the same entity may be described at different levels of detail during execution. This allows, for example, to focus on areas of interest by switching to a more detailed model, and revert back to a faster but less accurate one when possible. In this paper we propose GEMMA (GEneric Multilevel Modeling Abstraction), a methodology inspired by DEVS that can help the designer to produce sound and correct multilevel models. We propose a practical realization of GEMMA as a concrete software architecture that can be instantiated in different programming languages. We illustrate a simple use case where different sub-models written in different programming languages are combined according to the GEMMA methodology. Our ultimate goal is to bridge the gap between theory and practice of multilevel modeling, to foster a broader adoption of this useful technique.

Computing intersections among sets of one-dimensional intervals is an ubiquitous problem in computational geometry with important applications in bioinformatics, where the size of typical inputs is large and it is therefore important to use efficient algorithms. In this paper we propose a parallel algorithm for the 1D intersection-counting problem, that is, the problem of counting the number of intersections between each interval in a given set A and every interval in a set B. Our algorithm is suitable for shared-memory architectures (e.g., multicore CPUs) and GPUs. The algorithm is work-efficient because it performs the same amount of work as the best serial algorithm for this kind of problem. Our algorithm has been implemented in C++ using the Thrust parallel algorithms library, enabling the generation of optimized programs for multicore CPUs and GPUs from the same source code. The performance of our algorithm is evaluated on synthetic and real datasets, showing good scalability on different generations of hardware.

Multilevel modeling and simulation (M&S) is becoming increasingly relevant due to the benefits that this methodology offers. Multilevel models allow users to describe a system at multiple levels of detail. From one side, this can make better use of computational resources, since the more detailed and time-consuming models can be executed only when/where required. From the other side, multilevel models can be assembled from existing components, cutting down development and verification/validation time. A downside of multilevel M&S is that the development process becomes more complex due to some recurrent issues caused by the very nature of multilevel models: how to make sub-models interoperate, how to orchestrate execution, how state variables are to be updated when changing scale, and so on. In this paper, we address some of these issues by presenting a set of design patterns that provide a systematic approach for designing and implementing multilevel models. The proposed design patterns cover multiple aspects, including how to represent different levels of detail, how to combine incompatible models, how to exchange data across models, and so on. Some of the patterns are derived from the general software engineering literature, while others are specific to the multilevel M&S application area.

Multilevel modeling is increasingly relevant in the context of modelling and simulation since it leads to several potential benefits, such as software reuse and integration, the split of semantically separated levels into sub-models, the possibility to employ different levels of detail, and the potential for parallel execution. The coupling that inevitably exists between the sub-models, however, implies the need for maintaining consistency between the various components, more so when different simulation paradigms are employed (e.g., sequential vs parallel, discrete vs continuous). In this paper we argue that multilevel modelling is well suited for the simulation of human mobility, since it naturally leads to the decomposition of the model into two layers, the “micro” and “macro” layer, where individual entities (micro) and long-range interactions (macro) are described. In this paper we investigate the challenges of multilevel modeling, and describe some preliminary results using prototype implementations of multilayer simulators in the context of epidemic diffusion and vehicle pollution.

Mobile platforms have matured to a point where they can provide the infrastructure required to support sophisticated optimization codes. This opens the possibility to envisage new interest for distributed application codes and the opportunity to intensify research on optimization algorithms requiring limited computational resources, as provided by mobile platforms. In this article, we report on some exploratory experience in this area. We illustrate some practical, real-world cases where running optimization programs on mobile or embedded devices can be useful, with particular emphasis on matheuristics approaches. Then, we discuss a practical use case involving the feasibility version of the generalized assignment problem (GAP). We present a JavaScript implementation of a GAP solver that can be executed inside an ordinary browser supporting ECMAScript. We tested the code on different smartphones of varying age and power, as well as on desktop PCs and other embedded devices. Our experiments confirm the viability of mobile devices for computational intensive tasks.

Research on data confidentiality, integrity and availability is gaining momentum in the ICT community, due to the intrinsically insecure nature of the Internet. While many distributed systems and services are now based on secure communication protocols to avoid eavesdropping and protect confidentiality' the techniques usually employed in distributed simulations do not consider these issues at all. This is probably due to the fact that many real-world simulators rely on monolithic, offline approaches and therefore the issues above do not apply. However, the complexity of the systems to be simulated, and the rise of distributed and cloud based simulation, now impose the adoption of secure simulation architectures. This paper presents a solution to ensure both anonymity and confidentiality in distributed simulations. A performance evaluation based on an anonymized distributed simulator is used for quantifying the performance penalty for being anonymous. The obtained results show that this is a viable solution.

This paper presents a methodology for simulating the Internet of Things (IoT) using multi-level simulation models. With respect to conventional simulators, this approach allows us to tune the level of detail of different parts of the model without compromising the scalability of the simulation. As a use case, we have developed a two-level simulator to study the deployment of smart services over rural territories. The higher level is base on a coarse grained, agent-based adaptive parallel and distributed simulator. When needed, this simulator spawns OMNeT++ model instances to evaluate in more detail the issues concerned with wireless communications in restricted areas of the simulated world. The performance evaluation confirms the viability of multi-level simulations for IoT environments.

In this paper we consider the problem of identifying intersections between two sets of d-dimensional axis-parallel rectangles. This is a common operation that arises in many agent-based simulation studies, and is of central importance in the context of High Level Architecture (HLA), where it is at the core of the Data Distribution Management (DDM) service. Several realizations of the DDM service have been proposed; however, many of them are either inefficient or inherently sequential. We propose a parallel version of the Sort-Based Matching algorithm for shared-memory multiprocessors. SortBased Matching is one of the most efficient serial algorithms for the DDM problem, but is quite difficult to parallelize because of data dependencies. We describe the algorithm and compute its asymptotic running time; we complete the analysis by assessing its performance and scalability through extensive experiments on two commodity multicore systems based on a dual socket Intel Xeon processor, and a single socket Intel Core i7 processor.

Discrete Event Simulation is a widely used technique that is used to model and analyze complex systems in many fields of science and engineering. The increasingly large size of simulation models poses a serious computational challenge, since the time needed to run a simulation can be prohibitively large. For this reason, Parallel and Distributes Simulation techniques have been proposed to take advantage of multiple execution units which are found in multicore processors, cluster of workstations or HPC systems. The current generation of HPC systems includes hundreds of thousands of computing nodes and a vast amount of ancillary components. Despite improvements in manufacturing processes, failures of some components are frequent, and the situation will get worse as larger systems are built. In this paper we describe FT-GAIA, a software-based fault-tolerant extension of the GAIA/ARTIS parallel simulation middleware. FT-GAIA transparently replicates simulation entities and distributes them on multiple execution nodes. This allows the simulation to tolerate crash-failures of computing nodes, furthermore, FT-GAIA offers some protection against Byzantine failures since synchronization messages are replicated as well, so that the receiving entity can identify and discard corrupted messages. We provide an experimental evaluation of FT-GAIA on a running prototype. Results show that a high degree of fault tolerance can be achieved, at the cost of a moderate increase in the computational load of the execution units.

Modern applications, e.g., for pervasive computing scenarios, are increasingly reliant on systems built from multiple distributed components, which must be suitably composed to meet some specified functional and non-functional requirements. A key challenge is how to efficiently and effectively manage such complex systems. The use of self-management capabilities has been suggested as a possible way to address this challenge. To cope with the scalability and robustness issues of large distributed systems, self-management should ideally be architected in a decentralized way, where the overall system behavior emerges from local decisions and interactions. Within this context, we propose GOPRIME, a fully decentralized middleware solution for the adaptive self-assembly of distributed services. The GOPRIME goal is to build and maintain an assembly of services that, besides functional requirements, fulfils also global quality-of-service and structural requirements. The key aspect of GOPRIME is the use of a gossip protocol to achieve decentralized information dissemination and decision making. To show the validity of our approach, we present results from the experimentation of a prototype implementation of GOPRIME in a mobile health application, and an extensive set of simulation experiments that assess the effectiveness of GOPRIME in terms of scalability, robustness and convergence speed.

Identifying intersections among a set of d-dimensional rectangular regions (d-rectangles) is a common problem in many simulation and modeling applications. Since algorithms for computing intersections over a large number of regions can be computationally demanding, an obvious solution is to take advantage of the multiprocessing capabilities of modern multicore processors. Unfortunately, many solutions employed for the Data Distribution Management service of the High Level Architecture are either inefficient, or can only partially be parallelized. In this paper we propose the Interval Tree Matching(ITM) algorithm for computing intersections among d-rectangles. ITMis based on a simple Interval Tree data structure, and exhibits an embarrassingly parallel structure. We implement the ITM algorithm, and compare its sequential performance with two widely used solutions(brute force and sort-based matching). We also analyze the scalability of ITM on shared-memory multicore processors. The results show that the sequential implementation of ITM is competitive with sort-based matching, moreover, the parallel implementation provides good speed upon multicore processors.

The success of Cloud computing, where computing power is treated as a utility, has resulted in the creation of many large data centers that are very expensive to build and operate. In particular, the energy bill accounts for a significant fraction of the total operation costs. For this reason a significant attention is being devoted to energy conservation techniques, for example by taking advantage of the built-in power saving features of modern hardware. Cloud computing offers novel opportunities for achieving energy savings: Cloud systems rely on virtualization techniques to allocate computing resources on demand, and modern Virtual Machine (VM) monitors allow live migration of running VMs. Thus, energy conservation can be achieved through server consolidation, moving VM instances away from lightly loaded computing nodes so that they become empty and can be switched to low-power mode. In this paper we present V-MAN, a fully decentralized algorithm for consolidating VMs in large Cloud datacenters. V-MAN can operate on any arbitrary initial allocation of VMs on the Cloud, iteratively producing new allocations that quickly converge towards the one maximizing the number of idle hosts. V-MAN uses a simple gossip protocol to achieve efficiency, scalability and robustness to failures. Simulation experiments indicate that, starting from a random allocation, V-MAN produces an almost-optimal VM placement in just a few rounds; the protocol is intrinsically robust and can cope with computing nodes being added to or removed from the Cloud.

The OGSA-basic execution service (BES) specification has recently been proposed by the Open Grid Forum (OGF) as the standard job submission and management interface across different Grid middlewares. This specification defines a Web Service interface in terms of a Web Services Description Language (WSDL) document for creating, monitoring and managing computational jobs (called activities), and for querying the capabilities of the BES service itself. In this paper, we propose an alternate incarnation of the BES functionalities according to the representational state transfer (REST) architectural style. We describe the mapping of the BES operations in terms of HTTP actions on resources. We compare the REST formulation of BES with the standard WS-based one. We show that all BES operations can be expressed in a very natural way using the standard HTTP protocol and following the REST approach; moreover, we present useful extensions that are expected to appear in the near future.

Abstract Many production Grid and e‐Science infrastructures have begun to offer services to end‐users during the past several years with an increasing number of scientific applications that require access to a wide variety of resources and services in multiple Grids. Therefore, the Grid Interoperation Now—Community Group of the Open Grid Forum—organizes and manages interoperation efforts among those production Grid infrastructures to reach the goal of a world‐wide Grid vision on a technical level in the near future. This contribution highlights fundamental approaches of the group and discusses open standards in the context of production e‐Science infrastructures. Copyright © 2009 John Wiley & Sons, Ltd.

In a distributed grid environment with ambitious service demands the job submission and management interfaces provide functionality of major importance. Emerging e-science and grid infrastructures such as EGEE and DEISA rely on highly available services that are capable of managing scientific jobs. It is the adoption of emerging open standard interfaces which allows the distribution of grid resources in such a way that their actual service implementation or grid technologies are not isolated from each other, especially when these resources are deployed in different e-science infrastructures that consist of different types of computational resources. This paper motivates the interoperability of these infrastructures and discusses solutions. We describe the adoption of various open standards that recently emerged from the open grid forum (OGF) in the field of job submission and management by well-known grid technologies, respectively gLite and UNICORE. This has a fundamental impact on the interoperability between these technologies and thus within the next generation e-science infrastructures that rely on these technologies.

Many existing Grid technologies and resource management systems lack a standardized job submission interface in Grid environments or e-Infrastructures. Even if the same language for job description is used, often the interface for job submission is also different in each of these technologies. The evolvement of the standardized Job Submission and Description Language (JSDL) as well as the OGSA - Basic Execution Services (OGSA-BES) pave the way to improve the interoperability of all these technologies enabling cross-Grid job submission and better resource management capabilities. In addition, the BytelO standards provide useful mechanisms for data access that can be used in conjunction with these improved resource management capabilities. This paper describes the integration of these standards into the recently released UNICORE 6 Grid middleware that is based on open standards such as the Web Services Resource Framework (WS-RF) and WS-Addressing (WS-A).

Locating data on peer-to-peer networks is a complex issue addressed by many P2P protocols. Most of the research in this area only considers static content, that is, it is often assumed that data in P2P systems do not vary over time. In this paper, we describe a data location strategy for dynamic content on P2P networks. Data location exploits a distributed index based on bit vectors: this index is used to route queries towards areas of the system where matches can be found. The bit vectors can be efficiently updated when data is modified. Simulation results show that the proposed algorithms for queries and updates propagation have good performances, also on large networks, even if content exhibits a high degree of variability.

Quantitative performance analysis of software systems should be integrated in the software development process from the early stages. Software performance modelling and analysis allows the software designer to address performance related issues such as the comparison of design alternatives. Software performance modeling based on simulation models allows the analyst to represent detailed characteristics of the system and makes it easier the integration of the performance model with the software specification model. We propose simulation-based performance modeling of software architectures specified in UML. We argue that simulation-based performance models are well suited for capturing the complex aspects and behaviors of software systems. We propose a methodology for deriving a simulation model from annotated UML software architectures. We introduce the annotation for some UML diagrams, i.e., Use Case, Activity and Deployment diagrams, to describe system performance parameters. Then we show how to derive a discrete-event simulation model by automatically extracting information from the UML diagrams. Simulation provides performance results that are reported into the UML diagrams as tagged values. The proposed methodology has been implemented into a prototype tool called SAPS (Software Architectures Performance Simulator). We describe an application example of the proposed methodology. Keywords Software Performance Models, Discrete-Event Simulation, Unified Modeling Language (UML). 1