Merge branch 'dev'

Author: pbayer

NEWS.md

@@ -1,5 +1,10 @@
 # DiscreteEvents news 
 
+## v0.3.5
+(released 2023-02-23)
+- updated compat
+- removed multi-threading (parallel clocks) from export and docs
+
 ## v0.3.1
 
 (released 2020-09-16) A few days after the release of v0.3.0 Hector Perez contributed some macros to make the `DiscreteEvents` API more Julian for common cases:

Project.toml

@@ -1,7 +1,7 @@
 name = "DiscreteEvents"
 uuid = "127e53a7-d08a-4bd9-afb0-daf0d2b65a85"
 authors = ["Paul Bayer <Paul.Bayer@gleichsam.de>"]
-version = "0.3.4"
+version = "0.3.5"
 
 [deps]
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
@@ -12,7 +12,7 @@ Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 [compat]
 DataStructures = "0.17, 0.18"
-Distributions = "0.22, 0.23, 0.24"
+Distributions = "0.22, 0.23, 0.24, 0.25"
 Unitful = "1"
 julia = "1"
 

README.md

@@ -87,7 +87,7 @@ julia> include("examples/intro.jl")
 </code></pre>
 </details>
 
-For further examples see the [documentation](https://pbayer.github.io/DiscreteEvents.jl/dev),  or the companion site [DiscreteEventsCompanion](https://pbayer.github.io/DiscreteEventsCompanion.jl/dev/).
+For further examples see the [documentation](https://pbayer.github.io/DiscreteEvents.jl/dev).
 
 ## Installation
 

docs/make.jl

@@ -18,7 +18,6 @@ makedocs(
             "processes.md",
             "actors.md",
             "resources.md",
-            "parallel.md",
             "usage.md"],
         "Internals" => [
             "internals.md",

docs/src/clocks.md

@@ -39,52 +39,6 @@ You can query the current clock time:
 tau
 ```
 
-## Parallel Clocks (Experimental)
-
-Parallel clocks are a new feature in v0.3 and cannot yet considered to be stable. Please develop your applications first single-threaded before going parallel. Please report any failures.
-
-Parallel clocks are virtual clocks with local clocks on parallel threads to support multi-threaded simulations.
-
-A parallel clock structure consists of a master (global) clock on thread 1 and [`ActiveClock`](@ref)s on all available threads > 1. An active clock is a task running a thread local clock. The thread local clock can schedule and execute events locally.
-
-The master clock communicates with its parallel active clocks via message channels. It synchronizes time with the local clocks. Tasks (processes and actors) have access to their thread local clock from it and then work only with the local clock.
-
-```@docs
-PClock
-pclock
-```
-
-Parallel clocks can be identified by their thread number: the master clock works on thread 1, local clocks on parallel threads ≥ 2. They can be setup and accessed easily:
-
-```@repl clocks
-@show x=nthreads()-1;
-clk = PClock()       # now the clock has (+x) active parallel clocks
-ac2 = pclock(clk, 2) # access the active clock on thread 2
-ac2.clock            # the thread local clock
-ac2.clock.ac[]       # local clocks can access their active clock
-```
-
-Tasks on parallel threads have access to the thread local clock by `pclock(clk)`. Then they can schedule events, `delay!` or `wait!` on it as usual. The thread local clock is passed to a `process!` automatically if you set it up on a parallel thread.
-
-You can fork explicitly existing clocks to other threads or collapse them if no longer needed. You can get direct access to parallel active clocks and diagnose them.
-
-```@docs
-fork!
-collapse!
-```
-
-```@repl clocks
-clk = Clock()      # create a clock
-fork!(clk)         # fork it
-clk                # it now has parallel clocks
-collapse!(clk)     # collapse it
-clk                # it now has no parallel clocks
-```
-
-```@docs
-diagnose
-```
-
 ## Real Time Clocks (Experimental)
 
 Real time clocks are a new feature in v0.3 and thus cannot yet be considered as stable. Please try and report problems.

docs/src/history.md

@@ -3,6 +3,18 @@
 ```@meta
 CurrentModule = DiscreteEvents
 ```
+## v0.3.1
+A few days after the release of v0.3.0 Hector Perez contributed some macros to make the `DiscreteEvents` API more Julian for common cases:
+
+- [`@event`](@ref): wraps [`fun`](@ref) and [`event!`](@ref) into one call,
+- [`@periodic`](@ref): wraps [`fun`](@ref) and [`periodic!`](@ref) into one call,
+- [`@process`](@ref): wraps [`Prc`](@ref) and [`process!`](@ref) into one call,
+- [`@wait`](@ref): simplified call of [`wait!`](@ref),
+
+The following macros provide syntactic sugar to existing functions:
+
+- [`@delay`](@ref): calls [`delay!`](@ref),
+- [`@run!`](@ref): calls [`run!`](@ref).
 
 ## v0.3.0
 

docs/src/index.md

@@ -13,13 +13,9 @@ A Julia package for **discrete event generation and simulation**.
 - [**Troubleshooting**](troubleshooting.md): If something doesn't work as expected.
 - [**Version history**](history.md): A list of features and changes.
 
-## Companion
-
-There is a companion site [DiscreteEventsCompanion](https://pbayer.github.io/DiscreteEventsCompanion.jl/dev/) with more information, examples, notebooks and benchmarks.
-
 ## Development
 
-`DiscreteEvents` is in active development. Please use, test and help  evolve it. Its GitHub repository is at [https://github.com/pbayer/DiscreteEvents.jl](https://github.com/pbayer/DiscreteEvents.jl).
+`DiscreteEvents` is in development. Please use, test and help  evolve it. Its GitHub repository is at [https://github.com/pbayer/DiscreteEvents.jl](https://github.com/pbayer/DiscreteEvents.jl).
 
 **Author:** Paul Bayer
 **License:** MIT

docs/src/internals.md

@@ -27,18 +27,6 @@ LocalClock
 localClock
 ```
 
-**An example on active clocks:**
-
-```@repl
-using DiscreteEvents
-clk = Clock()         # create a clock
-fork!(clk)            # fork it to parallel threads
-clk                   # now you see parallel active clocks
-clk = PClock()        # create a parallel clock structure
-ac2 = pclock(clk, 2)  # get access to the active clock on thread 2
-ac2.clock             # access the parallel clock 2
-```
-
 `Schedule` and `ClockChannel` are two important `Clock` substructures:
 
 ```@docs

docs/src/news.md

@@ -1,20 +1,10 @@
-# News in v0.3.1
+# News in v0.3.5
 
 ```@meta
 CurrentModule = DiscreteEvents
 ```
 
-A few days after the release of v0.3.0 Hector Perez contributed some macros to make the `DiscreteEvents` API more Julian for common cases:
-
-- [`@event`](@ref): wraps [`fun`](@ref) and [`event!`](@ref) into one call,
-- [`@periodic`](@ref): wraps [`fun`](@ref) and [`periodic!`](@ref) into one call,
-- [`@process`](@ref): wraps [`Prc`](@ref) and [`process!`](@ref) into one call,
-- [`@wait`](@ref): simplified call of [`wait!`](@ref),
-
-The following macros provide syntactic sugar to existing functions:
-
-- [`@delay`](@ref): calls [`delay!`](@ref),
-- [`@run!`](@ref): calls [`run!`](@ref).
+- multithreading (parallel clocks) has been removed from exports, testing and documentation as it was unstable and has been broken by Julia 1.7 and 1.8
 
 ## Earlier releases
 

docs/src/old/clocks-parallel.md

@@ -0,0 +1,45 @@
+## Parallel Clocks (Experimental)
+
+Parallel clocks are a new feature in v0.3 and cannot yet considered to be stable. Please develop your applications first single-threaded before going parallel. Please report any failures.
+
+Parallel clocks are virtual clocks with local clocks on parallel threads to support multi-threaded simulations.
+
+A parallel clock structure consists of a master (global) clock on thread 1 and [`ActiveClock`](@ref)s on all available threads > 1. An active clock is a task running a thread local clock. The thread local clock can schedule and execute events locally.
+
+The master clock communicates with its parallel active clocks via message channels. It synchronizes time with the local clocks. Tasks (processes and actors) have access to their thread local clock from it and then work only with the local clock.
+
+```@docs
+PClock
+pclock
+```
+
+Parallel clocks can be identified by their thread number: the master clock works on thread 1, local clocks on parallel threads ≥ 2. They can be setup and accessed easily:
+
+```@repl clocks
+@show x=nthreads()-1;
+clk = PClock()       # now the clock has (+x) active parallel clocks
+ac2 = pclock(clk, 2) # access the active clock on thread 2
+ac2.clock            # the thread local clock
+ac2.clock.ac[]       # local clocks can access their active clock
+```
+
+Tasks on parallel threads have access to the thread local clock by `pclock(clk)`. Then they can schedule events, `delay!` or `wait!` on it as usual. The thread local clock is passed to a `process!` automatically if you set it up on a parallel thread.
+
+You can fork explicitly existing clocks to other threads or collapse them if no longer needed. You can get direct access to parallel active clocks and diagnose them.
+
+```@docs
+fork!
+collapse!
+```
+
+```@repl clocks
+clk = Clock()      # create a clock
+fork!(clk)         # fork it
+clk                # it now has parallel clocks
+collapse!(clk)     # collapse it
+clk                # it now has no parallel clocks
+```
+
+```@docs
+diagnose
+```