The Experts below are selected from a list of 78327 Experts worldwide ranked by ideXlab platform

Philip A. Wilsey - One of the best experts on this subject based on the ideXlab platform.

  • Annual Simulation Symposium - Working Set Based Scheduling in Time Warp Simulations
    40th Annual Simulation Symposium (ANSS'07), 2007
    Co-Authors: Malolan Chetlur, Philip A. Wilsey
    Abstract:

    This paper presents a new scheduling mechanism to choose and process the next input event from the event-set of Simulation Objects in a logical process (LP). Events are prioritized based on a Simulation Object's working set. Working set of a Simulation Object is analogous to working set defined in virtual memory, and consists of input and output events referenced in the recent past (without time-faults). The Simulation kernel exploits the causality framework to determine the working set size of a Simulation Object. In addition, the scheduler favors events that are within the estimated working set size. This working set based scheduling mechanism shows a performance improvement in the order or 10%-15%. This technique also improves the overall efficiency and memory utilization

  • Workshop on Parallel and Distributed Simulation - Causality representation and cancellation mechanism in time warp Simulations
    2001
    Co-Authors: Malolan Chetlur, Philip A. Wilsey
    Abstract:

    The Time Warp synchronization protocol allows causality errors and then recovers from them with the assistance of a cancellation mechanism. Cancellation can cause the rollback of several other Simulation Objects that may trigger a cascading rollback situation where the rollback cycles back to the original Simulation Object. These cycles of rollback can cause the Simulation to enter a unstable (or thrashing) state where little real forward Simulation progress is achieved. To address this problem, knowledge of causal relations between events can be used during cancellation to avoid cascading rollbacks and to initiate early recovery operations from causality errors. In this paper, we describe a logical time representation for Time Warp Simulations that is used to disseminate causality information. The new timestamp representation, called Total Clocks, has two components: (i) a virtual time component, and (ii) a vector of event counters similar to Vector clocks. The virtual time component provides a one dimensional global Simulation time, and the vector of event counters records event processing rates by the Simulation Objects. This time representation allows us to disseminate causality information during event execution that can be used to allow early recovery during cancellation. We propose a cancellation mechanism using Total Clocks that avoids cascading rollbacks in Time Warp Simulations that have FIFO communication channels.

  • IPPS - External adjustment of runtime parameters in Time Warp synchronized parallel simulators
    Proceedings 11th International Parallel Processing Symposium, 1
    Co-Authors: Radharamanan Radhakrishnan, Lantz Moore, Philip A. Wilsey
    Abstract:

    Several optimizations to the Time Warp synchronization protocol for parallel discrete event Simulation have been proposed and studied. Many of these optimizations have included some form of dynamic adjustment (or control) of the operating parameters of the Simulation (e.g. checkpoint interval, cancellation strategy). Traditionally dynamic parameter adjustment has been performed at the Simulation Object level; each Simulation Object collects measures of its operating behaviors (e.g. rollback frequency, rollback length, etc.) and uses them to adjust its operating parameters. The performance data collection functions and parameter adjustment are overhead costs that are incurred in the expectation of higher throughput. The paper presents a method of eliminating some of these overheads through the use of an external Object to adjust the control parameters. That is, instead of inserting code for adjusting Simulation parameters in the Simulation Object, an external control Object is defined to periodically analyze each Simulation Object's performance data and revise that Object's operating parameters. An implementation of an external control Object in the WARPED Time Warp Simulation kernel has been completed. The Simulation parameters updated by the implemented control system are: checkpoint interval, and cancellation strategy (lazy or aggressive). A comparative analysis of three test cases shows that the external control mechanism provides speedups between 5%-17% over the best performing embedded dynamic adjustment algorithms.

Francesco Quaglia - One of the best experts on this subject based on the ideXlab platform.

  • DS-RT - Towards a fully non-blocking share-everything PDES platform
    2017 IEEE ACM 21st International Symposium on Distributed Simulation and Real Time Applications (DS-RT), 2017
    Co-Authors: Mauro Ianni, Romolo Marotta, Alessandro Pellegrini, Francesco Quaglia
    Abstract:

    Shared-memory multi-core platforms are changing the nature of Parallel Discrete Event Simulation (PDES) because of the possibility to fully share the workload of events to be processed across threads. In this context, one rising PDES paradigm — referred to as share-everything PDES — is no longer based on the concept of (temporary) biding of Simulation Objects to worker threads. Rather, each worker threads can — at any time — pick from a fully shared event pool an event to process which can be destined to whatever Simulation Object. While attention has been posed on the design of concurrent shared pools, allowing non-blocking parallel operations, the scenario where two (or more) threads pick events destined to the same Simulation Object still lacks adequate synchronization support. In fact, these events are currently sequentialized and processed in a critical section touching the Simulation Object state, thus leading threads to mutually block each other. In this article we present the design of a share-everything speculative PDES engine that prevents mutual thread blocks because of the access to a same Object state. In our design, the non-blocking property is seen as a vertical attribute of the engine (not only of the event pool). This vertical view demands for innovative event-dispatching schemes and, at the same time, innovative interactions with (and management of) the fully-shared event pool, which are features that we embed in our innovative design.

  • SimuTools - A Non-Blocking Priority Queue for the Pending Event Set
    2016
    Co-Authors: Romolo Marotta, Mauro Ianni, Alessandro Pellegrini, Francesco Quaglia
    Abstract:

    The large diffusion of shared-memory multi-core machines has impacted the way Parallel Discrete Event Simulation (PDES) engines are built. While they were originally conceived as data-partitioned platforms, where each thread is in charge of managing a subset of Simulation Objects, nowadays the trend is to shift towards share-everything settings. In this scenario, any thread can (in principle) take care of CPU-dispatching pending events bound to whichever Simulation Object, which helps to fully share the load across the available CPU-cores. Hence, a fundamental aspect to be tackled is to provide an efficient globally-shared pending events' set from which multiple worker threads can concurrently extract events to be processed, and into which they can concurrently insert new produced events to be processed in the future. To cope with this aspect, we present the design and implementation of a concurrent non-blocking pending events' set data structure, which can be seen as a variant of a classical calendar queue. Early experimental data collected with a synthetic stress test are reported, showing excellent scalability of our proposal on a machine equipped with 32 CPU-cores.

  • SIGSIM-PADS - NUMA Time Warp
    Proceedings of the 3rd ACM SIGSIM Conference on Principles of Advanced Discrete Simulation, 2015
    Co-Authors: Alessandro Pellegrini, Francesco Quaglia
    Abstract:

    It is well known that Time Warp may suffer from large usage of memory, which may hamper the efficiency of the memory hierarchy. To cope with this issue, several approaches have been devised, mostly based on the reduction of the amount of used virtual memory, e.g., by the avoidance of checkpointing and the exploitation of reverse computing. In this article we present an orthogonal solution aimed at optimizing the latency for memory access operations when running Time Warp systems on Non-Uniform Memory Access (NUMA) multi-processor/multi-core computing systems. More in detail, we provide an innovative Linux-based architecture allowing per Simulation-Object management of memory segments made up by disjoint sets of pages, and supporting both static and dynamic binding of the memory pages reserved for an individual Object to the different NUMA nodes, depending on what worker thread is in charge of running that Simulation Object along a given wall-clock-time window. Our proposal not only manages the virtual pages used for the live state image of the Simulation Object, rather, it also copes with memory pages destined to keep the Simulation Object's event buffers and any recoverability data. Further, the architecture allows memory access optimization for data (messages) exchanged across the different Simulation Objects running on the NUMA machine. Our proposal is fully transparent to the application code, thus operating in a seamless manner. Also, a free software release of our NUMA memory manager for Time Warp has been made available within the open source ROOT-Sim Simulation platform. Experimental data for an assessment of our innovative proposal are also provided in this article.

  • SimuTools - An evolutionary algorithm to optimize log/restore operations within optimistic Simulation platforms
    2011
    Co-Authors: Alessandro Pellegrini, Roberto Vitali, Francesco Quaglia
    Abstract:

    In this work we address state recoverability in advanced optimistic Simulation systems by proposing an evolutionary algorithm to optimize at run-time the parameters associated with state log/restore activities. Optimization takes place by adaptively selecting for each Simulation Object both (i) the best suited log mode (incremental vs non-incremental) and (ii) the corresponding optimal value of the log interval. Our performance optimization approach allows to indirectly cope with hidden effects (e.g., locality) as well as cross-Object effects due to the variation of log/restore parameters for different Simulation Objects (e.g., rollback thrashing). Both of them are not captured by literature solutions based on analytical models of the overhead associated with log/restore tasks. More in detail, our evolutionary algorithm dynamically adjusts the log/restore parameters of distinct Simulation Objects as a whole, towards a well suited configuration. In such a way, we prevent negative effects on performance due to the biasing of the optimization towards individual Simulation Objects, which may cause reduced gains (or even decrease) in performance just due to the aforementioned hidden and/or cross-Object phenomena. We also present an application-transparent implementation of the evolutionary algorithm within the ROme OpTimistic Simulator (ROOT-Sim), namely an open source, general purpose Simulation environment designed according to the optimistic synchronization paradigm. Further, we provide the results of an experimental study testing our proposal on a suite of Simulation models for wireless communication systems.

  • An Evolutionary Algorithm to Optimize Log/Restore Operations within Optimistic Simulation Platforms
    Proceedings of the 4th International ICST Conference on Simulation Tools and Techniques, 2011
    Co-Authors: Alessandro Pellegrini, Roberto Vitali, Francesco Quaglia
    Abstract:

    In this work we address state recoverability in advanced optimistic Simulation systems by proposing an evolutionary algorithm to optimize at run-time the parameters associated with state log/restore activities. Optimization takes place by adaptively selecting for each Simulation Object both (i) the best suited log mode (incremental vs non-incremental) and (ii) the corresponding optimal value of the log interval. Our performance optimization approach allows to indirectly cope with hidden effects (e.g., locality) as well as cross-Object effects due to the variation of log/restore parameters for different Simulation Objects (e.g., rollback thrashing). Both of them are not captured by literature solutions based on analytical models of the overhead associated with log/restore tasks. More in detail, our evolutionary algorithm dynamically adjusts the log/restore parameters of distinct Simulation Objects as a whole, towards a well suited configuration. In such a way, we prevent negative effects on performance due to the biasing of the optimization towards individual Simulation Objects, which may cause reduced gains (or even decrease) in performance just due to the aforementioned hidden and/or cross-Object phenomena. We also present an application-transparent implementation of the evolutionary algorithm within the ROme OpTimistic Simulator (ROOT-Sim), namely an open source, general purpose Simulation environment designed according to the optimistic synchronization paradigm

Radharamanan Radhakrishnan - One of the best experts on this subject based on the ideXlab platform.

  • IPPS - External adjustment of runtime parameters in Time Warp synchronized parallel simulators
    Proceedings 11th International Parallel Processing Symposium, 1
    Co-Authors: Radharamanan Radhakrishnan, Lantz Moore, Philip A. Wilsey
    Abstract:

    Several optimizations to the Time Warp synchronization protocol for parallel discrete event Simulation have been proposed and studied. Many of these optimizations have included some form of dynamic adjustment (or control) of the operating parameters of the Simulation (e.g. checkpoint interval, cancellation strategy). Traditionally dynamic parameter adjustment has been performed at the Simulation Object level; each Simulation Object collects measures of its operating behaviors (e.g. rollback frequency, rollback length, etc.) and uses them to adjust its operating parameters. The performance data collection functions and parameter adjustment are overhead costs that are incurred in the expectation of higher throughput. The paper presents a method of eliminating some of these overheads through the use of an external Object to adjust the control parameters. That is, instead of inserting code for adjusting Simulation parameters in the Simulation Object, an external control Object is defined to periodically analyze each Simulation Object's performance data and revise that Object's operating parameters. An implementation of an external control Object in the WARPED Time Warp Simulation kernel has been completed. The Simulation parameters updated by the implemented control system are: checkpoint interval, and cancellation strategy (lazy or aggressive). A comparative analysis of three test cases shows that the external control mechanism provides speedups between 5%-17% over the best performing embedded dynamic adjustment algorithms.

Quaglia Francesco - One of the best experts on this subject based on the ideXlab platform.

  • A Distributed Shared Memory Middleware for Speculative Parallel Discrete Event Simulation
    'Association for Computing Machinery (ACM)', 2020
    Co-Authors: Principe Matteo, Tocci Tommaso, Di Sanzo Pierangelo, Quaglia Francesco, Pellegrini Alessandro
    Abstract:

    The large diffusion of multi-core machines has pushed the research in the field of Parallel Discrete Event Simulation (PDES) toward new programming paradigms, based on the exploitation of shared memory. On the opposite side, the advent of Cloud computing—and the possibility to group together many (low-cost) virtual machines to form a distributed memory cluster capable of hosting Simulation applications—has raised the need to bridge shared memory programming and seamless distributed execution. In this article, we present the design of a distributed middleware that transparently allows a PDES application coded for shared memory systems to run on clusters of (Cloud) resources. Our middleware is based on a synchronization protocol called Event and Cross State Synchronization. It allows cross-Simulation-Object access by event handlers, thus representing a powerful tool for the development of various types of PDES applications. We also provide data for an experimental assessment of our middleware architecture, which has been integrated into the open source ROOT-Sim speculative PDES platform

  • Approximated Rollbacks
    'Association for Computing Machinery (ACM)', 2020
    Co-Authors: Principe Matteo, Pellegrini Alessandro, Piccione Andrea, Quaglia Francesco
    Abstract:

    A rollback operation in a speculative parallel discrete event simulator has traditionally targeted the perfect reconstruction of the state to be restored after a timestamp-order violation. This imposes that the rollback support entails specific capabilities and consequently pays given costs. In this article we propose approximated rollbacks, which allow a Simulation Object to perfectly realign its virtual time to the timestamp of the state to be restored, but lead the reconstructed state to be an approximation of what it should really be. The advantage is an important reduction of the cost for managing the state restore task in a rollback phase, as well as for managing the activities (i.e. state saving) that actually enable rollbacks to be executed. Our proposal is suited for stochastic Simulations, and explores a tradeoff between the statistical representativeness of the outcome of the Simulation run and the execution performance. We provide mechanisms that enable the application programmer to control this tradeoff, as well as Simulation-platform level mechanisms that constitute the basis for managing approximate rollbacks in general Simulation scenarios. A study on the aforementioned tradeoff is also presented

  • Exploiting Inter-Processor-Interrupts for Virtual-Time Coordination in Speculative Parallel Discrete Event Simulation
    'Association for Computing Machinery (ACM)', 2020
    Co-Authors: Silvestri Emiliano, Pellegrini Alessandro, Milia Cristian, Marotta Romolo, Quaglia Francesco
    Abstract:

    Reducing the waste of resource usage (e.g., CPU-cycles) when a causality error occurs in speculative parallel discrete event Simulation (PDES) is still a core Objective. In this article, we target this Objective in the context of speculative PDES run on top of shared-memory machines. We propose an Operating System approach that is based on the exploitation of the Inter-Processor-Interrupt (IPI) facility offered by off-the-shelf hardware chipsets, which enables cross-CPU-core control of the execution flow of threads. As soon as a thread T produces a new event placed in the past virtual time of a Simulation Object currently run by another thread T′, our IPI-based support allows T to change the execution flow of T′—with very minimal delay—so to enable the early squash of the currently processed (and no longer consistent) event. Our solution is fully-transparent to the application level code, and is coupled with a lightweight heuristic-based mechanism that determines the actual goodness of killing thread T′ via the IPI (rather than skipping the IPI send) depending on the expected residual execution time of the incorrect event being processed. We integrated our proposal within the speculative open-source USE (Ultimate Share Everything) PDES package, and we report experimental results obtained by running various PDES models on top of two shared-memory hardware architectures equipped with 32 and 24 (48 Hyper-threads) CPU-cores, which demonstrate the effectiveness of our proposal

Xing Han-cheng - One of the best experts on this subject based on the ideXlab platform.

  • Intelligent Simulation Supporting Environment Research Based on HLA
    Computer Engineering, 2002
    Co-Authors: Xing Han-cheng
    Abstract:

    This paper introduces the concept of multi-agent in distributed artificial intelligence (DAI). It combines HLA Simulation technology framework with multi-agent technology, presents a Simulation supporting environment with intelligent characteristics, implements a common agent Simulation Object model, introduces the method of inter-operating with KQML,an agent communication language, and describes the working process of Simulation system.