Search

In an attempt to investigate blood unit ordering policies, researchers have created a discrete-event model of the UK National Blood Service (NBS) supply chain in the Southampton area of the UK. The model has been created using Simul8, a commercial off-the-shelf (COTS) discrete-event simulation package (CSP). However, as more hospitals were added to the model, it was discovered that the length of time needed to perform a single simulation severely increased. It has been claimed that distributed simulation, a technique that uses the resources of many computers to execute a simulation model, can reduce simulation runtime. Further, an emerging standardized approach exists that supports distributed simulation with CSPs. These CSP Interoperability (CSPI) standards are compatible with the IEEE 1516 standard, the High Level Architecture (HLA), the de facto interoperability standard for distributed simulation. To investigate if distributed simulation can reduce the execution time of NBS supply chain simulation, this paper presents experiences of creating a distributed version of the CSP Simul8 according to the CSPI/HLA standards. It shows that the distributed version of the simulation does indeed run faster when the model reaches a certain size. Further, we argue that understanding the relationship of model features is key to performance. This is illustrated by experimentation with two different protocols implementations (using Time Advance Request (TAR) and Next Event Request (NER)). Our contribution is therefore the demonstration that distributed simulation is a useful technique in the timely execution of supply chains of this type and that careful analysis of model features can further increase performance. [ABSTRACT FROM AUTHOR]

The very simple model known as Stupid Model was proposed in 2005. Stupid Model could be implemented within a couple of hours, and was later extended to demonstrate the use of common ABM platform functionality. Implementations of the model in several agent-based modeling platforms were provided, and platforms were compared for ease of implementation and performance. In this paper, Stupid Model is implemented in the EcoLab simulation platform (a C++ based modeling platform), demonstrating that it is a feasible platform for these sorts of models. The performance of the implementation is compared with the Repast, Mason and Swarm versions. [ABSTRACT FROM AUTHOR]

A commonly used task scheduling algorithm for parallel and distributed systems is gang scheduling. In this paper, we study gang scheduling performance in the presence of critical sporadic jobs. A simulation model is used to address performance issues associated with gang scheduling on distributed processors for various workloads. Simulated results indicate that the relative performance of the gang scheduling policies depends on the arrival rates of gangs and critical sporadic jobs and also on the variability in the critical sporadic jobs inter-arrival times. [ABSTRACT FROM AUTHOR]

Time Warp parallel simulations need efficient schemes to cancel erroneous event messages in order to achieve acceptable performance levels. Lazy cancellation depends on delaying the cancellation of incorrect computations until rolled-back events are re-processed. An antimessage is then sent for cancellation only if an output message re-produced after rollback is found to be unequal to its counterpart produced before rollback. One drawback of this approach is that antimessages are sent too late to catch the wave of incorrect computations, which results in more rollbacks. In this paper, we suggest an enhanced lazy cancellation technique that aims to throttle incorrect computations. It asks logical processes (LPs) that have received any output messages, generated from the first execution of a rolled-back input event in some neighboring LP, to mark those messages as temporarily blocked. Those messages remain in a blocked state until it is later decided whether or not they must be cancelled. The receiving LP becomes blocked only after a blocked input message becomes the next message to process. After re-executing the rolled-back input event, the sending LP sends each of its receiving LPs either an `Unblock' message or an antimessage for each previously marked output message, depending on the result of the equality test of that output message's versions before and after rollback. Experimental results for a synthetic benchmark show that our technique can yield better performance than both lazy and aggressive cancellation. [ABSTRACT FROM AUTHOR]