juliadynamics / concurrentsim.jl Goto Github PK

A discrete event process oriented simulation framework written in Julia. Formerly named SimJulia!

License: MIT License

Julia 100.00%

julia discrete-event-simulation discrete-event event-scheduler network-simulator

concurrentsim.jl's Introduction

ConcurrentSim (formerly SimJulia)

Documentation
Continuous integration
Code coverage
Static analysis with

A discrete event process oriented simulation framework written in Julia inspired by the Python library SimPy. One of the longest-lived Julia packages (originally under the name SimJulia).

Installation

ConcurrentSim.jl is a registered package, and is installed by running

julia> Pkg.add("ConcurrentSim")

License

Authors

Ben Lauwens, Royal Military Academy, Brussels, Belgium.
Maintainer volunteers from the JuliaDynamics and QuantumSavory organizations.

Contributing

To discuss problems or feature requests, file an issue. For bugs, please include as much information as possible, including operating system, julia version, and version of the dependencies: DataStructures and ResumableFunctions.
To contribute, make a pull request. Contributions should include tests for any new features/bug fixes.

Release Notes

A detailed change log is kept.

Alternatives

ConcurrentSim.jl and DiscreteEvents.jl both provide for typical event-based simulations. ConcurrentSim.jl is built around coroutines (implemented in ResumableFunctions.jl), while DiscreteEvents.jl uses Julia's async primitives via Channels. DiscreteEvents.jl has an explicit clock that "ticks" at a fixed finite resolution, while ConcurrentSim.jl uses coroutines to make arbitrary jumps in time. If you are evaluating which library to you for your goals, ConcurrentSim.jl might be a good choice if you are used to python's SimPy, but otherwise you are advised to try a small demo project in each and do your own benchmarks. Do not hesitate to submit issues on Github with questions or suggestions or feature requests. We value hearing what your experience with this library (compared to other libraries) has been.

concurrentsim.jl's People

Contributors

Stargazers

Watchers

concurrentsim.jl's Issues

Error in resources

Trying to run the bank example 20:

julia bank.jl

0.000 Customer01: Queue is 0 on arrival
0.000 Customer01: Waited 0.000
12.000 Customer01: Completed
17.300 Customer02: Queue is 0 on arrival
17.300 Customer02: Waited 0.000
19.016 Customer03: Queue is 0 on arrival
23.000 Ben: Queue is 1 on arrival
ERROR: no method typemin(CompositeKind,)
in findmax at array.jl:1276
in shift! at /home/tristan/.julia/SimJulia/src/priority_queue.jl:53
in release at /home/tristan/.julia/SimJulia/src/resources.jl:131
in visit at /home/tristan/abdn/Simulator/bank.jl:14
in anonymous at /home/tristan/.julia/SimJulia/src/processes.jl:70
at /home/tristan/abdn/Simulator/bank.jl:44
julia bank.jl
0.000 Customer01: Queue is 0 on arrival
0.000 Customer01: Waited 0.000
12.000 Customer01: Completed
17.300 Customer02: Queue is 0 on arrival
17.300 Customer02: Waited 0.000
19.016 Customer03: Queue is 0 on arrival
23.000 Ben: Queue is 1 on arrival
ERROR: no method typemin(CompositeKind,)
in findmax at array.jl:1276
in shift! at /home/tristan/.julia/SimJulia/src/priority_queue.jl:53
in release at /home/tristan/.julia/SimJulia/src/resources.jl:131
in visit at /home/tristan/abdn/Simulator/bank.jl:14
in anonymous at /home/tristan/.julia/SimJulia/src/processes.jl:70
at /home/tristan/abdn/Simulator/bank.jl:44

Request multiple resources

Is there any way of requesting 2 of a resource (for one process)? It seems like no...
I think the problem is that you can request twice, but it doesn't track that you have, so when you release it only releases once and then you can't release the other because the key is gone.
My hack is address it for now is to create a dummy process that holds the resource for the same amount of time, which seems to be working for my use-case.
Sorry for spamming up other issue!

ERROR: MethodError: no constructors have been defined for SimJulia.Environment

Hi,

I'm trying to run the fist example from the section "SimJulia in 10 Minutes" on Julia v 0.6.2, and get the following error:

ERROR: MethodError: no constructors have been defined for SimJulia.Environment

Is there any compatibility problem with version 0.6.2?

Thanks in advance for the help!

document difference between Resource, Store, and Container

LoadError: UndefVarError: active_proc not defined

I see an error when using show(env).
Line 33 of base.jl
print(io, "$(typeof(env)) time: $(now(env)) active_process: $(active_proc)")
should read
print(io, "$(typeof(env)) time: $(now(env)) active_process: $(env.active_proc)")
instead?

Citation reference?

Hi @BenLauwens, I want to cite SimJulia.jl on a paper I'm writing. Do you have a citation for this package?

set documentation builder to error on warnings (and clear up all the warnings)

This would make it easier to keep the documentation from bitrotting.

Crashes on upcoming Julia 1.3

While testing packages for 1.3 this package was noted to crash with:

Unreachable reached at 0x7fb7560115ff

signal (4): Illegal instruction
in expression starting at /root/.julia/packages/SimJulia/alkAr/test/processes.jl:45
execute at /root/.julia/packages/SimJulia/alkAr/src/processes.jl:32
#3 at /root/.julia/packages/SimJulia/alkAr/src/base.jl:51
_jl_invoke at /workspace/srcdir/julia/src/gf.c:2136 [inlined]
jl_apply_generic at /workspace/srcdir/julia/src/gf.c:2300
step at /root/.julia/packages/SimJulia/alkAr/src/simulations.jl:39
run at /root/.julia/packages/SimJulia/alkAr/src/base.jl:91
run at /root/.julia/packages/SimJulia/alkAr/src/events.jl:29
unknown function (ip: 0x7fb755fbf1c6)
_jl_invoke at /workspace/srcdir/julia/src/gf.c:2130 [inlined]
jl_apply_generic at /workspace/srcdir/julia/src/gf.c:2300
jl_apply at /workspace/srcdir/julia/src/julia.h:1631 [inlined]
do_call at /workspace/srcdir/julia/src/interpreter.c:328
eval_value at /workspace/srcdir/julia/src/interpreter.c:417
eval_stmt_value at /workspace/srcdir/julia/src/interpreter.c:368 [inlined]
eval_body at /workspace/srcdir/julia/src/interpreter.c:760

Since the code where it crashes are using a lot of functionality from ResumableFunctions.jl which touches a lot of the internals of Julia it is hard to know if this is an actual regression in Julia or an assumption about the internals by ResumableFunctions which is now no longer true.

Laundry simulation blog post as a test case.

Would be nice to have @IainNZ 's code from his blog post as a test case: Simulation Study of a Laundry Room

I am not sure if I am running it correctly, but I get:

julia> runSim(5.0, 234)
WARNING: add!(s::Set,x) is deprecated, use push!(s,x) instead.
 in depwarn at deprecated.jl:29
 in add! at deprecated.jl:19
 in register at /Users/viral/.julia/SimJulia/src/simulations.jl:129
 in Resource at /Users/viral/.julia/SimJulia/src/resources.jl:22
 in runSim at none:16
TimeAverage washers in use: 17.484833914398944
TimeAverage dryers in use: NaN
TimeAverage dryer queue length: NaN
NaN

New BoundsError in tests

Not sure if this is spurious, or if it was introduced by one of your dependencies changing something? Ref http://pkg.julialang.org/detail/SimJulia.html

Deprecation warnings after DataStructures update

Hi Ben,

I get the following (nasty) deprecation warnings when working with SimJulia:

WARNING: PriorityQueue{K, V}(::Type{K}, ::Type{V}) is deprecated, use PriorityQueue{K, V}() instead.

Stacktrace: [1] depwarn(::String, ::Symbol) at ./deprecated.jl:70 [2] DataStructures.PriorityQueue(::Type{SimJulia.Put}, ::Type{SimJulia.ContainerKey{Int64}}) at ./deprecated.jl:57 [3] Type at /Users/paul/.julia/v0.6/SimJulia/src/resources/containers.jl:15 [inlined] [4] #Resource#36 at /Users/paul/.julia/v0.6/SimJulia/src/resources/containers.jl:26 [inlined] [5] Type at /Users/paul/.julia/v0.6/SimJulia/src/resources/containers.jl:26 [inlined] [6] workunit(::SimJulia.Simulation, ::Int64, ::String, ::String, ::Int64, ::Int64, ::Int64, ::Int64, ::Int64, ::Int64, ::Int64) at /Users/paul/.julia/v0.6/PFlow/src/activities.jl:185 [7] readWorkunits(::String, ::SimJulia.Simulation) at /Users/paul/.julia/v0.6/PFlow/src/io.jl:20

This happens when I call Resource(sim, 1)

Thanks,
Paul

use the typical Base functions instead of declaring new ones (e.g. `get`, `put`, `release`, etc)

@BenLauwens , to make it easier to interoperate with other packages, I would like to start using the Base.get and Base.put! functions instead of the ConcurrentSim.get and ConcurrentSim.put.

For get this is actually already the case.

For put!, I suggest that we move all ConcurrentSim.put implementations to Base.put! implementations and keep ConcurrentSim.put as a wrapper around Base.put! with a deprecation warning (a deprecation that would not be acted upon for many years if ever, and that shows up only when someone runs tests, not in typical use, as it seems to be the convention for most Julia packages).

Let me know if you disagree with this approach.

@request macro does not yield

Hi Ben,

if I write (as you do e.g. in coroutines_MM1.jl ):

    println(@sprintf("%0.2f: Customer %d enqueues", now(sim), n))
    push!(queue, n)
    @request clerk req begin
        pop!(queue)
        println(@sprintf("%0.2f: Customer %d being served", now(sim), n))
        Δt = rand(DiscreteUniform(1, 5)) + randn()*0.2
        @yield return Timeout(sim, Δt)
    end
    println(@sprintf("%0.2f: Customer %d leaves after %0.2f min", now(sim), n, now(sim)-arrivaltime))

the process does not yield to requested resource clerk

whereas if I write explicitly:

    println(@sprintf("%0.2f: Customer %d enqueues", now(sim), n))
    push!(queue, n)
    @yield return Request(clerk)
    shift!(queue)
    println(@sprintf("%0.2f: Customer %d being served", now(sim), n))
    Δt = rand(DiscreteUniform(1, 5)) + randn()*0.2
    @yield return Timeout(sim, Δt)
    @yield return Release(clerk)
    println(@sprintf("%0.2f: Customer %d leaves after %0.2f min", now(sim), n, now(sim)-arrivaltime))

I get the right behaviour.

I included postoffice1.jlwhich does not yield and postoffice2.jl which works.

postoffice1.jl.txt
postoffice2.jl.txt

Paul

Difficulty updating examples to latest version

I'm trying to teach myself simJulia by converting the examples here to the format from here

I notice that running the code below results in Customers who arrive later finishing before Customers who arrived earlier - which should not be, since the Counter resource is of size 1.

This is a broad question, but: what am I doing wrong?

using ResumableFunctions
using SimJulia
using Distributions
const RANDOM_SEED = 150
const NEW_CUSTOMERS = 15  # Total number of customers
const INTERVAL_CUSTOMERS = 10.0  # Generate new customers roughly every x seconds
const MIN_PATIENCE = 1.0  # Min. customer patience
const MAX_PATIENCE = 3.0  # Max. customer patience
@resumable function source(env::Environment, number::Int, interval::Float64, counter::Resource)
  d = Exponential(interval)
  for i in 1:number
    @process customer(env, "Customer$i", counter, 12.0)
    @yield timeout(env, rand(d))
  end
end
@resumable function customer(env::Environment, name::String, counter::Resource, time_in_bank::Float64)
  arrive = now(env)
  println("$arrive $name: Here I am")
patience = rand(Uniform(MIN_PATIENCE, MAX_PATIENCE))
  req = request(counter)
  result = @yield (timeout(env, patience) | req)
  wait = now(env) - arrive
  if in(req, keys(result))
    println("$(now(env)) $name: Waited $wait")
    @yield timeout(env, rand(Exponential(time_in_bank)))
    println("$(now(env)) $name: Finished")
    @yield release(counter)
  else
    println("$(now(env)) $name: RENEGED after $wait")
    cancel(counter, req)
  end
end
# Setup and start the simulation
println("Bank renege")
srand(RANDOM_SEED)
env = Simulation()
# Start processes and run
counter = Resource(env, 1)
@process source(env, NEW_CUSTOMERS, INTERVAL_CUSTOMERS, counter)
run(env)

Output:

Bank renege
0.0 Customer1: Here I am
0.0 Customer1: Waited 0.0
4.435484832567573 Customer1: Finished
21.013085103081753 Customer2: Here I am
21.013085103081753 Customer2: Waited 0.0
23.097746900916643 Customer3: Here I am
23.91170855317896 Customer2: Finished
23.91170855317896 Customer3: Waited 0.8139616522623179
30.113622311091923 Customer4: Here I am
30.621135918022613 Customer5: Here I am
32.43509581615485 Customer5: Waited 1.8139598981322358
32.63868913452709 Customer3: Finished
32.63868913452709 Customer4: Waited 2.525066823435168
33.5396410887761 Customer4: Finished
35.0523510305572 Customer5: Finished
38.77969884703221 Customer6: Here I am
38.77969884703221 Customer6: Waited 0.0
47.99702198367206 Customer7: Here I am
48.64454625511486 Customer6: Finished
48.64454625511486 Customer7: Waited 0.6475242714427978
50.999475285814455 Customer7: Finished
52.47030443552359 Customer8: Here I am
52.47030443552359 Customer8: Waited 0.0
57.98071939500766 Customer8: Finished
58.25494691012832 Customer9: Here I am
58.25494691012832 Customer9: Waited 0.0
63.48304979696018 Customer10: Here I am
63.96737847606439 Customer9: Finished
63.96737847606439 Customer10: Waited 0.48432867910420896
66.07392655820522 Customer11: Here I am
68.85163326649807 Customer11: Waited 2.777706708292854
69.74637633123666 Customer12: Here I am
70.54002708087333 Customer13: Here I am
71.96036249140234 Customer12: Waited 2.2139861601656747
72.71560257832772 Customer13: Waited 2.175575497454389
73.31467582055163 Customer12: Finished
78.60049163270244 Customer14: Here I am
80.08557315904383 Customer13: Finished
81.37428653651419 Customer14: Waited 2.7737949038117478
85.63004525424745 Customer15: Here I am
88.53622453979828 Customer15: Waited 2.9061792855508344
89.26903543724671 Customer10: Finished
92.01728170444318 Customer15: Finished
100.1604596511923 Customer14: Finished
118.20001749424831 Customer11: Finished

As you can see, Customer14 finished before Customer11.

Versions:
Julia 0.6.2.1
ResumableFunctions: 0.1.10
SimJulia: 0.5.0

Help with simple simulation loop

Say I have a loop with simulations:

# some expensive simulation
simulation(i) = sleep(i)

results = []
for i in 1:100
   push!(results,  simulation(i))
end

I've added a try-catch block to interrupt the loop if the user presses CTR+C:

for i in 1:100
  try
     push!(results,  simulation(i))
  catch e
    e isa InterruptException && break
  end
end

Now I want to add another feature. Some of the simulations hang because they are too "difficult" to finish. I'd like to wait say 5min and if the simulation is still running, I would like to skip it in the loop. Can this package handle this use case? I am not familiar with discrete events, but it seems like it is a good approach? I am also open to Distributed solutions.

Support TimeType versus Float64 for time fields

I'm working on this on a branch but if this is a "will not happen" issue I'm happy enough to fork it and see where it goes.

TODO: Transparent statistics gathering for resources

I decided to open this issue to document the TODO item on the README.

Resource statistics of interest (please edit this list as deemed pertinent):

utilization: number of busy servers / total servers in each resource
put queue length: number of items in put queue
get queue length: number of items in get queue

Latest Documentation is empty

This only shows the index page: https://benlauwens.github.io/SimJulia.jl/latest/index.html
The sidebar is unpopulated.

Using the @request macro in the Bank Renege example

First I'd like to say thanks for the very useful package!

I'm trying to follow along with the bank renege example from the documentation but it looks like that example code is a little behind the stable release (e.g., @Process vs @process). Once I fix those I get an error when the Request() block runs. I saw in some other comments that you're working on the documentation but I was wondering if you could point me to some more info on the @request macro (or if I should be using Request() ).

Thanks!

add downstream breakage tests to CI

There are a few dependents on this library that probably should be tested to avoid accidentally breaking them. Some of them are private research projects of @BenLauwens , some of them are public like QuantumSavory.

Cannot load package: splitdef not defined

Hi,

I have just done Pkg.add("SimJulia"). Running using SimJulia gives the following error:

julia> using SimJulia
INFO: Precompiling module SimJulia.
ERROR: LoadError: LoadError: UndefVarError: splitdef not defined
Stacktrace:
 [1] include_from_node1(::String) at ./loading.jl:569
 [2] include(::String) at ./sysimg.jl:14
 [3] include_from_node1(::String) at ./loading.jl:569
 [4] include(::String) at ./sysimg.jl:14
 [5] anonymous at ./<missing>:2
while loading /Applications/JuliaPro-0.6.0.1.app/Contents/Resources/pkgs-0.6.0.1/v0.6/ResumableFunctions/src/macro.jl, in expression starting on line 1
while loading /Applications/JuliaPro-0.6.0.1.app/Contents/Resources/pkgs-0.6.0.1/v0.6/ResumableFunctions/src/ResumableFunctions.jl, in expression starting on line 13
ERROR: LoadError: Failed to precompile ResumableFunctions to /Applications/JuliaPro-0.6.0.1.app/Contents/Resources/pkgs-0.6.0.1/lib/v0.6/ResumableFunctions.ji.
Stacktrace:
 [1] compilecache(::String) at ./loading.jl:703
 [2] _require(::Symbol) at ./loading.jl:456
 [3] require(::Symbol) at ./loading.jl:398
 [4] include_from_node1(::String) at ./loading.jl:569
 [5] include(::String) at ./sysimg.jl:14
 [6] anonymous at ./<missing>:2
while loading /Applications/JuliaPro-0.6.0.1.app/Contents/Resources/pkgs-0.6.0.1/v0.6/SimJulia/src/SimJulia.jl, in expression starting on line 10
ERROR: Failed to precompile SimJulia to /Applications/JuliaPro-0.6.0.1.app/Contents/Resources/pkgs-0.6.0.1/lib/v0.6/SimJulia.ji.
Stacktrace:
 [1] compilecache(::String) at ./loading.jl:703
 [2] _require(::Symbol) at ./loading.jl:490
 [3] require(::Symbol) at ./loading.jl:398

I am running Julia 0.6.0 on OS X. I see that the package passes build on Julia 0.6, so I'm baffled. Any ideas? I tested this also on another machine -- Windows 10 and get the exact same error.

Stores.jl bug

I think line 221 in stores.jl should be >= rather than >, otherwise you can't get all items.

Thanks!

verify all basic types are concrete (and consider using sumtypes where possible)

Julia is not fast when working with containers over abstract types. In particular, the heap and other fields in the Simulation type are currently abstractly typed or have abstract eltypes. We need a thorough cleanup here, to ensure we do not introduce unnecessary slowdowns.

The first step is to verify that Simulation and its fields are all fully concrete (recursively into the type of each field). The biggest offender is the heap.

The second step would be to verify this for the rest of the major types introduced in the library.

Repository New Version

Is new version already available in Julia Repo?

Make Store.items a dequeue

Is there a specific reason why Store.items is a Set{T}?
In my opinion it makes for some counterintuitive behavior. For instance,

env = Simulation()
store = Store{Symbol}(env)
put(store, :apple)
put(store, :apple)
put(store, :pear)

gives

store.items
Set(Symbol[:pear, :apple])

which is counterintuitive as one would expect the store to contain two apples now; however, before making a pr, I wanted to know if there is some specific idea behind using Set.

Polling a resource / poor-mans spinlock

Is there a "proper" way to atomically check whether a resource is available in a non-blocking manner?

I want to write something along the lines of

while true:
    if isavailable(resource)
        @yield request(resource)
        break
    else
        @yield timeout(waittime)
    end
end

I am currently thinking about using resource.level == 0 but this seems like an internal implementation detail, not a real API.

Difficulty updating Event Latency example to SimJulia 0.5.1

I'm trying to update this example to SimJulia 0.5.1 to help myself learn. My attempt is shown below.

The first problem seems to be that the receiver function is in an infinite loop at time 0, and so the sender function never sends its first message at time 5. I can't understand how the previous version of the code worked, since the infinite loop should never end.

However, I tried to account for this by putting a timeout in the receiver function, and while the simulation sucessfully steps to SIM_DURATION, the sender never puts a message in cable.store - and I can't understand why not. It seems to me like the code is executing to put a value in cable.store, but then the receiver doesn't see the message. I added println everywhere to try figure it out, but it doesn't shed any light.

Attempt at updating code (Not working correctly)

using ResumableFunctions
using SimJulia
import SimJulia.put
import Base.get

const SIM_DURATION = 100.0

mutable struct Cable
  env :: Environment
  delay :: Float64
  store :: Store{String}
  function Cable(env::Environment, delay::Float64)
    cable = new()
    cable.env = env
    cable.delay = delay
    cable.store = Store{String}(env)
    return cable
  end
end

@resumable function latency(env::Environment, cable::Cable, value::String)
  println("Latency timeout starting")
  @yield timeout(env, cable.delay)
  println("Latency timeout finished, starting cable put")
  @yield put(cable.store, value)
end

function put(cable::Cable, value::String)
  println("put called, starting latency process")
  @process latency(cable.env, cable, value)
  println("Latency process exited, exiting put")
end

@resumable function get(cable::Cable)
  println("Fetching message from cable store")
  @yield Get(cable.store)
  println("Cable store message fetched")
end

@resumable function sender(env::Environment, cable::Cable)
  while true
    println("Sender waiting for 5 seconds")
    @yield timeout(env, 5.0)
    println("Sender finished waiting, put starting")
    put(cable, "Sender sent this at $(now(env))")
    println("Sender put process finished")
  end
end

@resumable function receiver(env::Environment, cable::Cable)
  while true
    println("Receiver is fetching message")
    msg = get(cable)
    println("Received this at $(now(env)) while $msg")
    println("Sender's message printed - surely we should put a delay in here?")
    # these lines added to try fix issue but it didn't help
    @yield timeout(env, 1)
    println("Receiver has finished waiting")
  end
end

println("Event latency")
env = Simulation()

cable = Cable(env, 10.0)
@process sender(env, cable)
@process receiver(env, cable)

run(env, SIM_DURATION)

Example output from above code:

Event latency
Sender waiting for 5 seconds
Receiver is fetching message
Received this at 0.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 0.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 1.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 1.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 2.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 2.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 3.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 3.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 4.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 4.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 5.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 5.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 6.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 6.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 7.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 7.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 8.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 8.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 9.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 9.0 active_process: n
othing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 10.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 10.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 11.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 11.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 12.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 12.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 13.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 13.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 14.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 14.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 15.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 15.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 16.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 16.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 17.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 17.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 18.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 18.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 19.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 19.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 20.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 20.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 21.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 21.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 22.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 22.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 23.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 23.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 24.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 24.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 25.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 25.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 26.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 26.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 27.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 27.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 28.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 28.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 29.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 29.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 30.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 30.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 31.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 31.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 32.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 32.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 33.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 33.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 34.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 34.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 35.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 35.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 36.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 36.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 37.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 37.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 38.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 38.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 39.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 39.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 40.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 40.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 41.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 41.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 42.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 42.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 43.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 43.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 44.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 44.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 45.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 45.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 46.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 46.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 47.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 47.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 48.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 48.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 49.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 49.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 50.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 50.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 51.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 51.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 52.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 52.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 53.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 53.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 54.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 54.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 55.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 55.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 56.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 56.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 57.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 57.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 58.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 58.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 59.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 59.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 60.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 60.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 61.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 61.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 62.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 62.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 63.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 63.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 64.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 64.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 65.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 65.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 66.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 66.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 67.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 67.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 68.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 68.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 69.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 69.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 70.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 70.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 71.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 71.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 72.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 72.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 73.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 73.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 74.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 74.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 75.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 75.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 76.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 76.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 77.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 77.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 78.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 78.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 79.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 79.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 80.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 80.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 81.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 81.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 82.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 82.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 83.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 83.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 84.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 84.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 85.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 85.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 86.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 86.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 87.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 87.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 88.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 88.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 89.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 89.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 90.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 90.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 91.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 91.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 92.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 92.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 93.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 93.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 94.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 94.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout finished, starting cable put
Sender finished waiting, put starting
put called, starting latency process
Latency process exited, exiting put
Sender put process finished
Sender waiting for 5 seconds
Receiver has finished waiting
Receiver is fetching message
Received this at 95.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 95.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Latency timeout starting
Receiver has finished waiting
Receiver is fetching message
Received this at 96.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 96.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 97.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 97.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 98.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 98.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?
Receiver has finished waiting
Receiver is fetching message
Received this at 99.0 while ##664(0x00, #undef, Cable(SimJulia.Simulation time: 99.0 active_process:
 nothing, 10.0, SimJulia.Store{String}))
Sender's message printed - surely we should put a delay in here?

SimJulia examples do not start

In a julia 0.6.1 (win10) installation, after Pkg.add("SimJulia") and then using SimJulia, then defining
function car(env::Environment)
while true
println("Start parking at $(now(env))")
parking_duration = 5.0
yield(Timeout(env, parking_duration))
println("Start driving at $(now(env))")
trip_duration = 2.0
yield(Timeout(env, trip_duration))
end
end
I am getting a ERROR message: UndefVarError: Environment is not defined.
Where is the problem with this very basic example?
Thanks
Rainer

Any Plan for v0.6?

Hello, nice package!
Are there any plans supporting julia v0.6?

Best Regards,
smldis

404 error for stable docs

I tried to access the stable docs via the link on README file. I got 404 error.

[PackageEvaluator.jl] Your package SimJulia may have a testing issue.

This issue is being filed by a script, but if you reply, I will see it.

PackageEvaluator.jl is a script that runs nightly. It attempts to load all Julia packages and run their test (if available) on both the stable version of Julia (0.2) and the nightly build of the unstable version (0.3).

The results of this script are used to generate a package listing enhanced with testing results.

The status of this package, SimJulia, on...

Julia 0.2 is 'No tests, but package loads.'
Julia 0.3 is 'No tests, but package loads.'

'No tests, but package loads.' can be due to their being no tests (you should write some if you can!) but can also be due to PackageEvaluator not being able to find your tests. Consider adding a test/runtests.jl file.

'Package doesn't load.' is the worst-case scenario. Sometimes this arises because your package doesn't have BinDeps support, or needs something that can't be installed with BinDeps. If this is the case for your package, please file an issue and an exception can be made so your package will not be tested.

This automatically filed issue is a one-off message. Starting soon, issues will only be filed when the testing status of your package changes in a negative direction (gets worse). If you'd like to opt-out of these status-change messages, reply to this message.

32-bit system issues

On my 32-bit system I get the following error.

julia> Simulation(uint64(16))
ERROR: no method EventList(Uint64,)
 in Simulation at /home/amitm/.julia/SimJulia/src/simulations.jl:13

I suspect that such type errors may exist elsewhere in the package too.

Error tagging new release

The tag name "V0.4.1" is not of the appropriate SemVer form (vX.Y.Z).
cc: @BenLauwens

Continuous Simulation

Hi Ben!

Is the continuous simulation part you presented at JuliaCon only available on the continuous branch right now?

External simulator

Is it possible to use your package to schedule a range of simulations (which I
start as a shell command) and distribute them on different computers?

Bank Renege example minor bug

In the example Bank Renege (http://simjuliajl.readthedocs.io/en/stable/examples/1_bank_renege.html), the line
cancel(counter, req)
does not work with the last version of SimJulia, and should be replaced by
cancel(req)

Note: I was not able to access the documentation on GitHub

Add Iain's blog post example as a test case

Would be nice to have @IainNZ 's code from his blog post as a test case: http://iaindunning.com/2013/simulation-study-of-a-laundry-room.html`

Support for Discrete Time

Dear Ben:

I need to develop a simple discrete event simulation model for discrete time updates (e.g., monthly) without any consideration of resources. I am wondering if SimJulia can be configured to handle discrete time updates.

Thanks,
Tae Yoon Lee

Error when building documentation

When I try to build the documentation locally, I get the following error:

$ julia make.jl
ERROR: LoadError: ArgumentError: makedocs() got passed invalid keyword arguments:
strict = true
Stacktrace:
[...]

If I go into make.jl and remove the "strict = true" line, the documentation builds as expected.

If this is not a problem with the code but instead a problem with how I tried to use it, then I apologize.

I am completely new to collaborating on github, and any feedback would be greatly appreciated.

Output statistics?

This is perhaps a trivial question, but I couldn't figure out how to do it in an easy way.

Take the Bank Renege example. I'd like to simulate 1000 customers and in the end obtain the mean waiting time as well as the frequency of reneging among the last 500 customers. How should I do it? In the documented example, the status of each customer is printed out. But I simply want some statistics output after the simulation is done. How should I do it?

enable preemption of jobs

There is an old PR that can help with that #71

Add QSS solver to the common interface?

Hey, I was wondering if you could add bindings to the DifferentialEquations.jl common interface so that way the QSS solver could be benchmarked against the other ODE integrators. I am seeing nice claims but I haven't seen benchmarks against the other implementations so I am curious how well it performs in practice.

Parallel calculation using multiple cores

I have developed a traffic simulation platform using SimJulia. When the network is larger, the simulation is not quick enough. How to run the simulation parallelly?

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

document similarities and differences with DiscreteEvents.jl

Would be nice if this is stated in the readme!

Add API Functions for process and resource state inspection

Some ideas of API functions to add:

Check if a resource is available (isavailable()). See #76
Check if an event is idle, processed or scheduled (isprocessed(), etc)

how to specify preemption = true when requesting a resource

Hi, I am trying to work through examples in the resource section of older documentation by converting it to current version. I was able to get the priority resource example to work.

using ResumableFunctions
using SimJulia

@resumable function resource_user(env::Environment, name::Int, res::Resource, wait::Float64, prio::Int)
    @yield timeout(env, wait)
    println("$name requesting at $(now(env)) with priority $prio")
    @yield request(res, priority = prio)
    println("$name got resource at $(now(env))")
    @yield timeout(env, 3.0)
    @yield release(res)
end

sim = Simulation()
res = Resource(sim, 1)
@process resource_user(sim, 1, res, 0.0, 0)
@process resource_user(sim, 2, res, 1.0, 0)
@process resource_user(sim, 3, res, 2.0, -1)
run(sim)

However when I try the following code to allow for preemption, it doesn't work. I couldn't figure out how to specify preemption=true during resource request. I would appreciate any guidance.

@resumable function resource_user(env::Environment, name::Int, res::Resource, wait::Float64, prio::Int)
    @yield timeout(env, wait)
    println("$name requesting at $(now(env)) with priority $prio")
    @yield request(res, priority = prio, preempt = true)
    println("$name got resource at $(now(env))")
    try
        @yield timeout(env, 3.0)
        @yield release(res)
    catch exc
        pre = cause(exc)
        usage = now(env) - usage_since(pre)
        println("$name got preempted by $(by(pre)) at $(now(env)) after $usage")
    end
end

sim = Simulation()
res = Resource(sim, 1)
@process resource_user(sim, 1, res, 0.0, 0)
@process resource_user(sim, 2, res, 1.0, 0)
@process resource_user(sim, 3, res, 2.0, -1)
run(sim)

Last commit to master branch lost several src/ files

c02ba17 has mysteriously lost src/ and src/resources files

Rank priority function in StorePutKey

Hi @BenLauwens,

How much work would it take for the priory of a Put object to be dynamic? This would allow implementing age based scheduling policies in a queue with preemption (https://ziv.codes/pdf/sigmetrics2018-scully.pdf). This way, the priority would be a function where the priority changes over time. Since we only track time at event boundaries, I'm thinking this approach may not be possible. Let me know what you think.

Thanks

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.