1,721,112 research outputs found
Premio Tesi di Dottorato 2015
No full textThis thesis tackles simulation, which (from the Latin simulare, to “fake” or to “replicate”) is the imitation of a real-world process’ or system’s operation over time. Using simulation, it is possible to collect results very quickly, long before the actual phenomenon occurs, or a particular system is built. It is a very powerful and versatile analytic and experimental instrument, so that it is used in medicine, biology, physics, and economics, just to mention a few application fields. Nevertheless, models are becoming always more refined, and the size of the data sets is getting always larger. This requires an ever increasing computing power to keep simulation times reduced, as in the past.
The advent of multicore technology has given a new impulse to performance increase of computing systems, after that the last decade has seen a significant slowdown. Yet, it has introduced new obstacles as well: the increased complexity of software implementation, verification, and validation. Regarding simulation, this is of great difficulty for the experts of fields not directly related to computer science, possibly preventing them from fully relying on the computing power that is available nowadays.
This publication tackles this issue in the field of discrete-event simulation. In particular, several techniques and methodologies are presented, which allow to move the problem of simulation-model parallelization to the runtime environment in charge of executing it. In this way, it is possible to run in parallel a model implemented in a sequential fashion, benefiting at the same time from the increased computing power and from the much simpler and more intuitive programming model
Hijacker
No full textHijacker is an open-source customizable static binary instrumentation tool which is able to alter a program's execution flow according to some user-specified rules, limiting the execution overhead due to the code snippets inserted in the original program, thus enabling for the exploitation in high performance computing. The tool is highly modular and works on an internal representation of the program which allows to perform complex instrumentation tasks efficiently, and can be additionally extended to support different instruction sets and executable formats without any need to modify the instrumentation engine.
It is based on C technology and it is currently being tested on executables generated by different compilers. Currently, Hijacker is able to instrument executables represented in the ELF binary format and using x86 or x86_64 instruction sets. A PE interpreter and an ARM disassembler are currently under active development
Techniques for Transparent Parallelization of Discrete Event Simulation Models
Full text linkSimulation is a powerful technique to represent the evolution of real-world phenomena
or systems over time. It has been extensively used in different research
fields (from medicine to biology, to economy, and to disaster rescue) to study
the behaviour of complex systems during their evolution (symbiotic simulation)
or before their actual realization (what-if analysis).
A traditional way to achieve high performance simulations is the employment
of Parallel Discrete Event Simulation (PDES) techniques, which are based
on the partitioning of the simulation model into Logical Processes (LPs) that
can execute events in parallel on different CPUs and/or different CPU cores,
and rely on synchronization mechanisms to achieve causally consistent execution
of simulation events. As it is well recognized, the optimistic synchronization
approach, namely the Time Warp protocol, which is based on rollback for recovering
possible timestamp-order violations due to the absence of block-until-safe
policies for event processing, is likely to favour speedup in general application/
architectural contexts.
However, the optimistic PDES paradigm implicitly relies on a programming
model that shifts from traditional sequential-style programming, given
that there is no notion of global address space (fully accessible while processing
events at any LP). Furthermore, there is the underlying assumption that the
code associated with event handlers cannot execute unrecoverable operations
given their speculative processing nature. Nevertheless, even though no unrecoverable
action is ever executed by event handlers, a means to actually undo
the action if requested needs to be devised and implemented within the software
stack.
On the other hand, sequential-style programming is an easy paradigm for
the development of simulation code, given that it does not require the programmer
to reason about memory partitioning (and therefore message passing) and
speculative (concurrent) processing of the application.
In this thesis, we present methodological and technical innovations which
will show how it is possible, by developing innovative runtime mechanisms, to
allow a programmer to implement its simulation model in a fully sequential way,
and have the underlying simulation framework to execute it in parallel according
to speculative processing techniques. Some of the approaches we provide show
applicability in either shared- or distributed-memory systems, while others will
be specifically tailored to multi/many-core architectures.
We will clearly show, during the development of these supports, what is the
effect on performance of these solutions, which will nevertheless be negligible,
allowing a fruitful exploitation of the available computing power. In the end,
we will highlight which are the clear benefits on the programming model tha
Hijacker: Efficient static software instrumentation with applications in high performance computing: Poster paper
Full text linkStatic Binary Instrumentation is a technique that allows compile-time program manipulation. In particular, by relying on ad-hoc tools, the end user is able to alter the program's execution flow without affecting its overall semantic. This technique has been effectively used, e.g., to support code profiling, performance analysis, error detection, attack detection, or behavior monitoring. Nevertheless, efficiently relying on static instrumentation for producing executables which can be deployed without affecting the overall performance of the application still presents technical and methodological issues. In this paper, we present Hijacker, an open-source customizable static binary instrumentation tool which is able to alter a program's execution flow according to some user-specified rules, limiting the execution overhead due to the code snippets inserted in the original program, thus enabling for the exploitation in high performance computing. The tool is highly modular and works on an internal representation of the program which allows to perform complex instrumentation tasks efficiently, and can be additionally extended to support different instruction sets and executable formats without any need to modify the instrumentation engine. We additionally present an experimental assessment of the overhead induced by the injected code in real HPC applications. © 2013 IEEE
Parallelization of Discrete Event Simulation Models
No full textSimulation is a powerful technique to represent the evolution of realworld
phenomena or systems over time. It has been extensively used
in different research fields (from medicine to biology, from economy, to
disaster rescue) to study the behaviour of complex systems during their
evolution (symbiotic simulation) or before their actual realization (what-if
analysis).
A traditional way to achieve high performance simulations is the
employment of Parallel Discrete Event Simulation (PDES) techniques,
which are based on the partitioning of the simulation model into Logical
Processes (LPs) that can execute events in parallel on different CPUs
and/or different CPU cores, and rely on synchronization mechanisms
to achieve causally consistent execution of simulation events. As it is
well recognized, the optimistic synchronization approach, namely the
Time Warp protocol, which is based on rollback for recovering possible
timestamp-order violations due to the absence of block-until-safe policies
for event processing, is likely to favour speedup in general application/
architectural contexts.
However, the optimistic PDES paradigm implicitly relies on a programming
model that drifts from traditional sequential-style programming,
given that there is no notion of global address space (fully accessible
while processing events at any LP). Furthermore, there is the
underlying assumption that the code associated with event handlers
cannot execute unrecoverable operations given their speculative processing
nature. Nevertheless, even though no unrecoverable action is ever
executed by event handlers, some means to actually undo the action
upon request needs to be devised and implemented within the software
stack.On the other hand, sequential-style programming is a very easy
paradigm for the development of simulation code, given that it does
not require the programmer to reason about memory partitioning (and
therefore message passing) and speculative (concurrent) processing of
the application.
In this thesis, we present methodological and technical innovations
which will show how it is possible, by developing innovative runtime
mechanisms, to allow a programmer to implement his simulation model
in a fully sequential way, and have the underlying simulation framework
to execute it in parallel according to speculative processing techniques.
Some of the approaches we provide show applicability in either sharedor
distributed-memory systems, while others will be specifically tailored
to multi/many-core architectures.
We will clearly show, during the development of these supports, what
is the effect on performance of these solutions, which will nevertheless
be negligible, allowing a fruitful exploitation of the available computing
power. In the end, we will highlight which are the clear benefits on the
programming model that the developer will experience by relying on
these innovative solutions
On the optimization of collaborative kerbside waste collection
Full text linkIn this paper, we target collaborative kerbside collection from a planning and real-time monitoring point of view. This is a non-trivial problem, where several vehicles are set on streets to finish a task—the collection of all waste—by a certain maximum amount of time. While deciding upon a collaborative strategy is a well-studied and complex problem by itself, we focus as well on re-planning, whenever live data collected by the vehicles suggest that the current scenario has deviated from the provisional plan, due to changes in external environmental factors. To this end, we propose a global mission-management architecture, which tries to optimize at once the time required to finish the waste collection, the distance traveled by the vehicles, the amount of fuel burnt (accounting as well for idle time at collection points), and the impact of pollutants emissions. Key–Words: Kerbside Collection, Optimization, Re-Routing, Real-Time, Deep Learning, Schedulin
Optimizing memory management for optimistic simulation with reinforcement learning
Full text linkSimulation is a powerful technique to explore complex scenarios and analyze systems related to a wide range of disciplines. To allow for an efficient exploitation of the available computing power, speculative Time Warp-based Parallel Discrete Event Simulation is universally recognized as a viable solution. In this context, the rollback operation is a fundamental building block to support a correct execution even when causality inconsistencies are a posteriori materialized. If this operation is supported via checkpoint/restore strategies, memory management plays a fundamental role to ensure high performance of the simulation run. With few exceptions, adaptive protocols targeting memory management for Time Warp-based simulations have been mostly based on a pre-defined analytic models of the system, expressed as a closed-form functions that map system's state to control parameters. The underlying assumption is that the model itself is optimal. In this paper, we present an approach that exploits reinforcement learning techniques. Rather than assuming an optimal control strategy, we seek to find the optimal strategy through parameter exploration. A value function that captures the history of system feedback is used, and no a-priori knowledge of the system is required. An experimental assessment of the viability of our proposal is also provided for a mobile cellular system simulation
- …
