├── .clang-format
├── .gitignore
├── include
    └── fschuetz04
    │   ├── simcpp20.hpp
    │   └── simcpp20
    │       ├── CMakeLists.txt
    │       ├── awaitable.hpp
    │       ├── promise_type.hpp
    │       ├── resource.hpp
    │       ├── value_event.hpp
    │       ├── store.hpp
    │       ├── process.hpp
    │       ├── value_process.hpp
    │       ├── event.hpp
    │       └── simulation.hpp
├── examples
    ├── value_event.cpp
    ├── any_of.cpp
    ├── clocks.cpp
    ├── value_process.cpp
    ├── all_of.cpp
    ├── clocks_units.cpp
    ├── CMakeLists.txt
    ├── store.cpp
    ├── ping_pong.cpp
    ├── any_of_process.cpp
    ├── carwash.cpp
    ├── bank_renege.cpp
    └── machine_shop.cpp
├── .github
    └── workflows
    │   ├── windows.yml
    │   └── linux.yml
├── tests
    ├── CMakeLists.txt
    ├── store_tests.cpp
    ├── awaitable_tests.cpp
    ├── resource_tests.cpp
    └── tests.cpp
├── CMakeSettings.json
├── CMakeLists.txt
├── LICENSE
└── README.md


/.clang-format:
--------------------------------------------------------------------------------
1 | BasedOnStyle: LLVM
2 | AllowShortFunctionsOnASingleLine: Inline
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /.cache
2 | /.vs
3 | /.vscode
4 | /build
5 | /debug
6 | /out
7 | /release
8 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // IWYU pragma: begin_exports
 4 | #include "simcpp20/awaitable.hpp"
 5 | #include "simcpp20/event.hpp"
 6 | #include "simcpp20/process.hpp"
 7 | #include "simcpp20/resource.hpp"
 8 | #include "simcpp20/simulation.hpp"
 9 | #include "simcpp20/store.hpp"
10 | #include "simcpp20/value_event.hpp"
11 | #include "simcpp20/value_process.hpp"
12 | // IWYU pragma: end_exports
13 | 


--------------------------------------------------------------------------------
/examples/value_event.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | simcpp20::process<> consumer(simcpp20::simulation<> &sim,
 6 |                              simcpp20::value_event<int> ev) {
 7 |   auto val = co_await ev;
 8 |   printf("[%.0f] val = %d\n", sim.now(), val);
 9 | }
10 | 
11 | int main() {
12 |   simcpp20::simulation<> sim;
13 |   auto ev = sim.timeout<int>(1, 42);
14 |   consumer(sim, ev);
15 |   sim.run();
16 | }
17 | 


--------------------------------------------------------------------------------
/examples/any_of.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | simcpp20::process<> process(simcpp20::simulation<> &sim) {
 6 |   printf("[%.0f] 1\n", sim.now());
 7 | 
 8 |   co_await (sim.timeout(1) | sim.timeout(2));
 9 |   printf("[%.0f] 2\n", sim.now());
10 | 
11 |   co_await (sim.timeout(1) | sim.event());
12 |   printf("[%.0f] 3\n", sim.now());
13 | }
14 | 
15 | int main() {
16 |   simcpp20::simulation<> sim;
17 |   process(sim);
18 |   sim.run();
19 | }
20 | 


--------------------------------------------------------------------------------
/examples/clocks.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | simcpp20::process<> clock_proc(simcpp20::simulation<> &sim, char const *name,
 6 |                                double delay) {
 7 |   while (true) {
 8 |     printf("[%.0f] %s\n", sim.now(), name);
 9 |     co_await sim.timeout(delay);
10 |   }
11 | }
12 | 
13 | int main() {
14 |   simcpp20::simulation<> sim;
15 |   clock_proc(sim, "slow", 2);
16 |   clock_proc(sim, "fast", 1);
17 |   sim.run_until(5);
18 | }
19 | 


--------------------------------------------------------------------------------
/examples/value_process.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | simcpp20::value_process<int> producer(simcpp20::simulation<> &sim) {
 6 |   co_await sim.timeout(1);
 7 |   co_return 42;
 8 | }
 9 | 
10 | simcpp20::process<> consumer(simcpp20::simulation<> &sim) {
11 |   auto val = co_await producer(sim);
12 |   printf("[%.0f] val = %d\n", sim.now(), val);
13 | }
14 | 
15 | int main() {
16 |   simcpp20::simulation<> sim;
17 |   consumer(sim);
18 |   sim.run();
19 | }
20 | 


--------------------------------------------------------------------------------
/examples/all_of.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | simcpp20::process<> process(simcpp20::simulation<> &sim) {
 6 |   printf("[%.0f] 1\n", sim.now());
 7 | 
 8 |   co_await (sim.timeout(1) & sim.timeout(2));
 9 |   printf("[%.0f] 2\n", sim.now());
10 | 
11 |   // sim.event() will never be triggered -> the resulting event will never
12 |   // be triggered too
13 |   co_await (sim.timeout(1) & sim.event());
14 |   printf("[%.0f] 3\n", sim.now());
15 | }
16 | 
17 | int main() {
18 |   simcpp20::simulation<> sim;
19 |   process(sim);
20 |   sim.run();
21 | }
22 | 


--------------------------------------------------------------------------------
/.github/workflows/windows.yml:
--------------------------------------------------------------------------------
 1 | name: Windows
 2 | on:
 3 |   push:
 4 |     branches: [main]
 5 |   pull_request:
 6 |     branches: [main]
 7 | jobs:
 8 |   build:
 9 |     strategy:
10 |       matrix:
11 |         os: [windows-latest]
12 |         build_type: [Debug, Release]
13 |     runs-on: ${{matrix.os}}
14 |     steps:
15 |       - uses: actions/checkout@v4.0.0
16 |       - name: Configure
17 |         run: cmake -B build
18 |       - name: Build
19 |         run: cmake --build build --config ${{matrix.build_type}}
20 |       - name: Test
21 |         run: build/tests/${{matrix.build_type}}/tests
22 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | FetchContent_Declare(Catch2
 4 |   GIT_REPOSITORY https://github.com/catchorg/Catch2
 5 |   GIT_TAG        6e79e682b726f524310d55dec8ddac4e9c52fb5f) # v3.4.0
 6 | FetchContent_MakeAvailable(Catch2)
 7 | 
 8 | add_executable(tests
 9 |   tests.cpp
10 |   awaitable_tests.cpp
11 |   resource_tests.cpp
12 |   store_tests.cpp)
13 | target_link_libraries(tests PRIVATE
14 |   fschuetz04::simcpp20
15 |   Catch2::Catch2WithMain)
16 | target_compile_options(tests PRIVATE
17 |   $<$<CXX_COMPILER_ID:MSVC>:/W4>
18 |   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic>
19 | )
20 | 


--------------------------------------------------------------------------------
/.github/workflows/linux.yml:
--------------------------------------------------------------------------------
 1 | name: Linux
 2 | on:
 3 |   push:
 4 |     branches: [main]
 5 |   pull_request:
 6 |     branches: [main]
 7 | jobs:
 8 |   build:
 9 |     strategy:
10 |       matrix:
11 |         os: [ubuntu-latest]
12 |         cxx: [g++, clang++]
13 |         build_type: [Debug, Release]
14 |     runs-on: ${{matrix.os}}
15 |     steps:
16 |       - uses: actions/checkout@v4.0.0
17 |       - name: Configure
18 |         run: CXX=${{matrix.cxx}} cmake -B build -D CMAKE_BUILD_TYPE=${{matrix.build_type}}
19 |       - name: Build
20 |         run: cmake --build build
21 |       - name: Test
22 |         run: build/tests/tests
23 | 


--------------------------------------------------------------------------------
/CMakeSettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "configurations": [
 3 |     {
 4 |       "buildRoot": "${projectDir}\\out\\build\\${name}",
 5 |       "configurationType": "Debug",
 6 |       "generator": "Ninja",
 7 |       "inheritEnvironments": [ "msvc_x64_x64" ],
 8 |       "installRoot": "${projectDir}\\out\\install\\${name}",
 9 |       "name": "VS Debug"
10 |     },
11 |     {
12 |       "buildRoot": "${projectDir}\\out\\build\\${name}",
13 |       "configurationType": "RelWithDebInfo",
14 |       "generator": "Ninja",
15 |       "inheritEnvironments": [ "msvc_x64_x64" ],
16 |       "installRoot": "${projectDir}\\out\\install\\${name}",
17 |       "name": "VS Release"
18 |     }
19 |   ]
20 | }


--------------------------------------------------------------------------------
/examples/clocks_units.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | #include "units.h"
 5 | 
 6 | using namespace units::literals;
 7 | 
 8 | using time_type = units::time::second_t;
 9 | using process = simcpp20::process<time_type>;
10 | using simulation = simcpp20::simulation<time_type>;
11 | 
12 | process clock_proc(simulation &sim, char const *name, time_type delay) {
13 |   while (true) {
14 |     std::cout << "[" << sim.now() << "] " << name << std::endl;
15 |     co_await sim.timeout(delay);
16 |   }
17 | }
18 | 
19 | int main() {
20 |   simulation sim;
21 |   clock_proc(sim, "slow", 2_s);
22 |   clock_proc(sim, "fast", 1_s);
23 |   sim.run_until(5_s);
24 | }
25 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_library(fschuetz04_simcpp20 INTERFACE)
 2 | add_library(fschuetz04::simcpp20 ALIAS fschuetz04_simcpp20)
 3 | 
 4 | target_include_directories(fschuetz04_simcpp20 INTERFACE ${PROJECT_SOURCE_DIR}/include)
 5 | target_compile_features(fschuetz04_simcpp20 INTERFACE cxx_std_20)
 6 | 
 7 | if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 8 |   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "10")
 9 |     message(WARNING "SimCpp20 requires GCC 10 or later")
10 |   endif()
11 |   target_compile_options(fschuetz04_simcpp20 INTERFACE -fcoroutines)
12 | endif()
13 | 
14 | if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
15 |   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.28")
16 |     message(WARNING "SimCpp20 requires MSVC 19.28 or later")
17 |   endif()
18 | endif()
19 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.14...3.31)
 2 | 
 3 | if(DEFINED PROJECT_NAME)
 4 |   set(MAIN_PROJECT OFF)
 5 | else()
 6 |   set(MAIN_PROJECT ON)
 7 |   set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 8 | endif()
 9 | 
10 | project(simcpp20
11 |   VERSION      0.1.0
12 |   DESCRIPTION  "Discrete-event simulation in C++20 using coroutines"
13 |   HOMEPAGE_URL "https://github.com/fschuetz04/simcpp20"
14 |   LANGUAGES    CXX)
15 | 
16 | add_subdirectory(include/fschuetz04/simcpp20)
17 | 
18 | option(FSCHUETZ04_SIMCPP20_BUILD_TESTS "Build tests" ${MAIN_PROJECT})
19 | if(FSCHUETZ04_SIMCPP20_BUILD_TESTS)
20 |   add_subdirectory(tests)
21 | endif()
22 | 
23 | option(FSCHUETZ04_SIMCPP20_BUILD_EXAMPLES "Build examples" ${MAIN_PROJECT})
24 | if(FSCHUETZ04_SIMCPP20_BUILD_EXAMPLES)
25 |   add_subdirectory(examples)
26 | endif()
27 | 
28 | 


--------------------------------------------------------------------------------
/examples/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | OPTION(BUILD_TESTS OFF)
 4 | FetchContent_Declare(units
 5 |   GIT_REPOSITORY https://github.com/nholthaus/units
 6 |   GIT_TAG        1e2c7ed7cd8e61db7a82b8827caef7ed49b01831)
 7 | FetchContent_MakeAvailable(units)
 8 | 
 9 | set(TARGETS
10 |   all_of
11 |   any_of
12 |   any_of_process
13 |   bank_renege
14 |   carwash
15 |   clocks
16 |   clocks_units
17 |   machine_shop
18 |   ping_pong
19 |   store
20 |   value_event
21 |   value_process)
22 | 
23 | foreach(TARGET ${TARGETS})
24 |   add_executable(${TARGET} ${TARGET}.cpp)
25 |   target_link_libraries(${TARGET} PRIVATE fschuetz04::simcpp20)
26 |   target_compile_options(${TARGET} PRIVATE
27 |     $<$<CXX_COMPILER_ID:MSVC>:/W4>
28 |     $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic>
29 |   )
30 | endforeach()
31 | 
32 | target_link_libraries(clocks_units PRIVATE units)
33 | 


--------------------------------------------------------------------------------
/examples/store.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | #include "fschuetz04/simcpp20/process.hpp"
 5 | 
 6 | simcpp20::process<> producer(simcpp20::simulation<> &sim,
 7 |                              simcpp20::store<int> &store) {
 8 |   for (int i = 0; i < 5; ++i) {
 9 |     co_await store.put(i);
10 |     printf("[%2.0f] store <- %d\n", sim.now(), i);
11 |   }
12 | }
13 | 
14 | simcpp20::process<> consumer(simcpp20::simulation<> &sim,
15 |                              simcpp20::store<int> &store) {
16 |   for (int i = 0; i < 5; ++i) {
17 |     co_await sim.timeout(5);
18 |     auto value = co_await store.get();
19 |     printf("[%2.0f] store -> %d\n", sim.now(), value);
20 |   }
21 | }
22 | 
23 | int main() {
24 |   simcpp20::simulation<> sim;
25 |   simcpp20::store<int> store{sim, 1};
26 |   producer(sim, store);
27 |   consumer(sim, store);
28 |   sim.run();
29 | }
30 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/awaitable.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional> // std::function
 4 | 
 5 | namespace simcpp20 {
 6 | 
 7 | /// An interface for objects that can be awaited.
 8 | class awaitable {
 9 | public:
10 |   /// Destructor.
11 |   virtual ~awaitable() = default;
12 | 
13 |   /// @return Whether the awaitable is pending.
14 |   virtual bool pending() const = 0;
15 | 
16 |   /// @return Whether the event is triggered or processed.
17 |   virtual bool triggered() const = 0;
18 | 
19 |   /// @return Whether the awaitable is processed.
20 |   virtual bool processed() const = 0;
21 | 
22 |   /// @return Whether the awaitable is aborted.
23 |   virtual bool aborted() const = 0;
24 | 
25 |   /**
26 |    * Add a callback to be called when the awaitable is processed.
27 |    *
28 |    * @param cb Callback.
29 |    */
30 |   virtual void add_callback(std::function<void()> cb) const = 0;
31 | };
32 | 
33 | } // namespace simcpp20
34 | 


--------------------------------------------------------------------------------
/examples/ping_pong.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | struct ev_type;
 6 | using ev_inner = simcpp20::value_event<ev_type>;
 7 | struct ev_type {
 8 |   ev_inner ev;
 9 | };
10 | 
11 | simcpp20::process<> party(simcpp20::simulation<> &sim, const char *name,
12 |                           simcpp20::value_event<ev_type> my_event,
13 |                           double delay) {
14 |   while (true) {
15 |     auto their_event = (co_await my_event).ev;
16 |     printf("[%.0f] %s\n", sim.now(), name);
17 |     co_await sim.timeout(delay);
18 |     my_event = sim.event<ev_type>();
19 |     their_event.trigger(ev_type{my_event});
20 |   }
21 | }
22 | 
23 | int main() {
24 |   simcpp20::simulation<> sim;
25 |   auto pong_event = sim.event<ev_type>();
26 |   auto ping_event = sim.timeout<ev_type>(0, ev_type{pong_event});
27 |   party(sim, "ping", ping_event, 1);
28 |   party(sim, "pong", pong_event, 2);
29 |   sim.run_until(8);
30 | }
31 | 


--------------------------------------------------------------------------------
/examples/any_of_process.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "fschuetz04/simcpp20.hpp"
 4 | 
 5 | simcpp20::process<> producer(simcpp20::simulation<> &sim, int id,
 6 |                              double delay) {
 7 |   printf("[%.0f] Producer %d starting\n", sim.now(), id);
 8 |   co_await sim.timeout(delay);
 9 |   printf("[%.0f] Producer %d finished\n", sim.now(), id);
10 | }
11 | 
12 | simcpp20::process<> consumer(simcpp20::simulation<> &sim) {
13 |   printf("[%.0f] Consumer starting\n", sim.now());
14 | 
15 |   // Create two producer processes
16 |   auto p1 = producer(sim, 1, 5);
17 |   auto p2 = producer(sim, 2, 10);
18 | 
19 |   // Wait for any producer to finish
20 |   co_await (p1 | p2);
21 |   printf("[%.0f] First producer finished\n", sim.now());
22 | 
23 |   // Wait for all producers to finish
24 |   co_await (p1 & p2);
25 |   printf("[%.0f] All producers finished\n", sim.now());
26 | }
27 | 
28 | int main() {
29 |   simcpp20::simulation<> sim;
30 |   consumer(sim);
31 |   sim.run();
32 | }
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright © 2025 Felix Schütz
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/examples/carwash.cpp:
--------------------------------------------------------------------------------
 1 | // See https://simpy.readthedocs.io/en/latest/examples/carwash.html
 2 | 
 3 | #include <cstdio>
 4 | #include <random>
 5 | 
 6 | #include "fschuetz04/simcpp20.hpp"
 7 | 
 8 | struct config {
 9 |   int initial_cars;
10 |   double wash_time;
11 |   simcpp20::resource<> machines;
12 |   std::uniform_int_distribution<> arrival_time_dist;
13 |   std::default_random_engine gen;
14 | };
15 | 
16 | simcpp20::process<> wash(simcpp20::simulation<> &sim, config &conf, int id) {
17 |   co_await sim.timeout(conf.wash_time);
18 |   printf("[%4.1f] Car %d washed\n", sim.now(), id);
19 | }
20 | 
21 | simcpp20::process<> car(simcpp20::simulation<> &sim, config &conf, int id) {
22 |   printf("[%4.1f] Car %d arrives\n", sim.now(), id);
23 | 
24 |   auto request = conf.machines.request();
25 |   co_await request;
26 | 
27 |   printf("[%4.1f] Car %d enters\n", sim.now(), id);
28 | 
29 |   co_await wash(sim, conf, id);
30 | 
31 |   printf("[%4.1f] Car %d leaves\n", sim.now(), id);
32 |   conf.machines.release();
33 | }
34 | 
35 | simcpp20::process<> car_source(simcpp20::simulation<> &sim, config &conf) {
36 |   for (int id = 1;; ++id) {
37 |     if (id > conf.initial_cars) {
38 |       co_await sim.timeout(conf.arrival_time_dist(conf.gen));
39 |     }
40 | 
41 |     car(sim, conf, id);
42 |   }
43 | }
44 | 
45 | int main() {
46 |   simcpp20::simulation<> sim;
47 | 
48 |   std::random_device rd;
49 |   config conf{
50 |       .initial_cars = 4,
51 |       .wash_time = 5,
52 |       .machines = simcpp20::resource{sim, 2},
53 |       .arrival_time_dist = std::uniform_int_distribution<>{3, 7},
54 |       .gen = std::default_random_engine{rd()},
55 |   };
56 | 
57 |   car_source(sim, conf);
58 | 
59 |   sim.run_until(20);
60 | }
61 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/promise_type.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cassert>   // assert
 4 | #include <coroutine> // std::coroutine_handle, std::suspend_never
 5 | 
 6 | namespace simcpp20 {
 7 | 
 8 | template <typename Time> class simulation;
 9 | template <typename Time> class event;
10 | 
11 | } // namespace simcpp20
12 | 
13 | namespace simcpp20::internal {
14 | 
15 | /**
16 |  * Abstract base class for all promise types.
17 |  *
18 |  * @tparam Time Type used for simulation time.
19 |  */
20 | template <typename Time = double> class generic_promise_type {
21 | public:
22 |   /// Constructor.
23 |   generic_promise_type(simulation<Time> &sim, std::coroutine_handle<> handle)
24 |       : sim_{sim}, handle_{handle} {
25 |     sim_.handles_.insert(handle_);
26 |   }
27 | 
28 |   /// Destructor.
29 |   virtual ~generic_promise_type() { sim_.handles_.erase(handle_); };
30 | 
31 |   /// @return Whether this process is aborted.
32 |   virtual bool is_aborted() const = 0;
33 | 
34 |   /// @return Coroutine handle associated with the process.
35 |   std::coroutine_handle<> process_handle() const { return handle_; }
36 | 
37 |   /**
38 |    * Called when the coroutine is started. The coroutine awaits the return
39 |    * value before running.
40 |    *
41 |    * @return Event which will be processed at the current simulation time.
42 |    */
43 |   event<Time> initial_suspend() const { return sim_.timeout(Time{0}); }
44 | 
45 |   /// Called when an exception is thrown inside the coroutine and not handled.
46 |   void unhandled_exception() const { assert(false); }
47 | 
48 |   /**
49 |    * Called after the coroutine returns.
50 |    *
51 |    * @return Awaitable which is always ready.
52 |    */
53 |   std::suspend_never final_suspend() const noexcept { return {}; }
54 | 
55 |   /// Reference to the simulation.
56 |   simulation<Time> &sim_;
57 | 
58 |   /// Coroutine handle.
59 |   std::coroutine_handle<> handle_;
60 | };
61 | 
62 | } // namespace simcpp20::internal
63 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/resource.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint> // uint64_t
 4 | #include <queue>   // std::queue
 5 | 
 6 | #include "event.hpp"
 7 | #include "simulation.hpp"
 8 | 
 9 | namespace simcpp20 {
10 | 
11 | /**
12 |  * A shared resource holding a number of instances.
13 |  *
14 |  * @tparam Time Type used for simulation time.
15 |  */
16 | template <typename Time = double> class resource {
17 | public:
18 |   /**
19 |    * Constructor.
20 |    *
21 |    * @param sim Reference to the simulation.
22 |    * @param available Number of available instances. Defaults to 0.
23 |    */
24 |   explicit resource(simulation<Time> &sim, uint64_t available = 0)
25 |       : sim_{sim}, available_{available} {}
26 | 
27 |   /**
28 |    * Request an instance of the resource.
29 |    *
30 |    * @return An event that will be triggered once an instance is available,
31 |    * which may be immediately.
32 |    */
33 |   event<Time> request() {
34 |     auto ev = sim_.event();
35 |     requests_.push(ev);
36 |     trigger_requests();
37 |     return ev;
38 |   }
39 | 
40 |   /// Release an instance of the resource.
41 |   void release() {
42 |     ++available_;
43 |     trigger_requests();
44 |   }
45 | 
46 |   /// @return Number of available instance.
47 |   uint64_t available() { return available_; }
48 | 
49 | private:
50 |   /// Pending request events.
51 |   std::queue<event<Time>> requests_ = {};
52 | 
53 |   /// Reference to the simulation.
54 |   simulation<Time> &sim_;
55 | 
56 |   /// Number of available instances.
57 |   uint64_t available_;
58 | 
59 |   /// Triggger pending request events until the resource is empty.
60 |   void trigger_requests() {
61 |     while (available() > 0 && requests_.size() > 0) {
62 |       auto ev = requests_.front();
63 |       requests_.pop();
64 |       if (ev.aborted()) {
65 |         continue;
66 |       }
67 | 
68 |       ev.trigger();
69 |       --available_;
70 |     }
71 |   }
72 | };
73 | 
74 | } // namespace simcpp20
75 | 


--------------------------------------------------------------------------------
/examples/bank_renege.cpp:
--------------------------------------------------------------------------------
 1 | // See https://simpy.readthedocs.io/en/latest/examples/bank_renege.html
 2 | 
 3 | #include <cstdio>
 4 | #include <random>
 5 | 
 6 | #include "fschuetz04/simcpp20.hpp"
 7 | 
 8 | struct config {
 9 |   int n_customers;
10 |   simcpp20::resource<> counters;
11 |   std::uniform_real_distribution<> max_wait_time_dist;
12 |   std::exponential_distribution<> arrival_interval_dist;
13 |   std::exponential_distribution<> service_time_dist;
14 |   std::default_random_engine gen;
15 | };
16 | 
17 | simcpp20::process<> customer(simcpp20::simulation<> &sim, config &conf,
18 |                              int id) {
19 |   printf("[%5.1f] Customer %d arrives\n", sim.now(), id);
20 | 
21 |   auto request = conf.counters.request();
22 |   auto max_wait_time = conf.max_wait_time_dist(conf.gen);
23 |   co_await (request | sim.timeout(max_wait_time));
24 | 
25 |   if (!request.triggered()) {
26 |     request.abort();
27 |     printf("[%5.1f] Customer %d RENEGES\n", sim.now(), id);
28 |     co_return;
29 |   }
30 | 
31 |   printf("[%5.1f] Customer %d gets to the counter\n", sim.now(), id);
32 | 
33 |   co_await sim.timeout(conf.service_time_dist(conf.gen));
34 | 
35 |   printf("[%5.1f] Customer %d leaves\n", sim.now(), id);
36 |   conf.counters.release();
37 | }
38 | 
39 | simcpp20::process<> customer_source(simcpp20::simulation<> &sim, config &conf) {
40 |   for (int id = 1; id <= conf.n_customers; ++id) {
41 |     customer(sim, conf, id);
42 |     co_await sim.timeout(conf.arrival_interval_dist(conf.gen));
43 |   }
44 | }
45 | 
46 | int main() {
47 |   simcpp20::simulation<> sim;
48 | 
49 |   std::random_device rd;
50 |   config conf{
51 |       .n_customers = 5,
52 |       .counters = simcpp20::resource{sim, 1},
53 |       .max_wait_time_dist = std::uniform_real_distribution<>{1., 3.},
54 |       .arrival_interval_dist = std::exponential_distribution<>{1. / 10},
55 |       .service_time_dist = std::exponential_distribution<>{1. / 12},
56 |       .gen = std::default_random_engine{rd()},
57 |   };
58 | 
59 |   customer_source(sim, conf);
60 | 
61 |   sim.run();
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/store_tests.cpp:
--------------------------------------------------------------------------------
 1 | #include "catch2/catch_test_macros.hpp"
 2 | #include "fschuetz04/simcpp20.hpp"
 3 | #include "fschuetz04/simcpp20/simulation.hpp"
 4 | 
 5 | #include <vector> // std::vector
 6 | 
 7 | TEST_CASE("store") {
 8 |   SECTION("immediate get returns value") {
 9 |     simcpp20::simulation<> sim;
10 |     simcpp20::store<int> store(sim);
11 | 
12 |     store.put(42);
13 |     auto ev = store.get();
14 | 
15 |     // for an immediately available value, the event should be triggered
16 |     REQUIRE(ev.triggered());
17 |     REQUIRE(ev.value() == 42);
18 |   }
19 | 
20 |   SECTION("queued get is triggered after put") {
21 |     simcpp20::simulation<> sim;
22 |     simcpp20::store<int> store(sim);
23 |     int result = 0;
24 | 
25 |     // process that gets a value and records it
26 |     auto proc = [&store, &result](auto &) -> simcpp20::process<> {
27 |       result = co_await store.get();
28 |     };
29 | 
30 |     proc(sim);
31 | 
32 |     store.put(55);
33 |     sim.run();
34 | 
35 |     REQUIRE(result == 55);
36 |   }
37 | 
38 |   SECTION("capacity constraint re-queues extra puts") {
39 |     simcpp20::simulation<> sim;
40 |     simcpp20::store<int> store(sim, 1);
41 |     auto put1 = store.put(100);
42 |     auto put2 = store.put(200); // queued
43 |     bool finished = false;
44 | 
45 |     REQUIRE(put1.triggered());
46 |     REQUIRE(!put2.triggered());
47 | 
48 |     // process that gets a value, waits for put2, and then gets a second value
49 |     auto proc = ([&put2, &store, &finished](auto &) -> simcpp20::process<> {
50 |       auto value = co_await store.get();
51 |       REQUIRE(value == 100);
52 | 
53 |       co_await put2;
54 | 
55 |       value = co_await store.get();
56 |       REQUIRE(value == 200);
57 | 
58 |       finished = true;
59 |     });
60 | 
61 |     proc(sim);
62 | 
63 |     sim.run();
64 | 
65 |     REQUIRE(finished);
66 |   }
67 | 
68 |   SECTION("multiple queued gets are triggered in order") {
69 |     simcpp20::simulation<> sim;
70 |     simcpp20::store<int> store(sim);
71 |     std::vector<int> results;
72 | 
73 |     // define a process that gets a value and records it
74 |     auto consumer = [&store, &results](auto &) -> simcpp20::process<> {
75 |       auto ev = store.get();
76 |       results.push_back(ev.value());
77 |       co_return;
78 |     };
79 | 
80 |     consumer(sim);
81 |     consumer(sim);
82 |     consumer(sim);
83 | 
84 |     store.put(10);
85 |     store.put(20);
86 |     store.put(30);
87 | 
88 |     sim.run();
89 |     REQUIRE(results == std::vector<int>{10, 20, 30});
90 |   }
91 | }
92 | 


--------------------------------------------------------------------------------
/examples/machine_shop.cpp:
--------------------------------------------------------------------------------
 1 | // See https://simpy.readthedocs.io/en/latest/examples/machine_shop.html
 2 | 
 3 | #include <cstdio>
 4 | #include <random>
 5 | 
 6 | #include "fschuetz04/simcpp20.hpp"
 7 | 
 8 | struct config {
 9 |   double repair_time;
10 |   simcpp20::resource<> repair_man;
11 |   std::normal_distribution<> time_for_part_dist;
12 |   std::exponential_distribution<> time_to_failure_dist;
13 |   std::default_random_engine gen;
14 | };
15 | 
16 | class machine {
17 | public:
18 |   machine(simcpp20::simulation<> &sim, config &conf)
19 |       : sim{sim}, conf{conf}, failure{sim.event()} {
20 |     produce();
21 |     fail();
22 |   }
23 | 
24 |   int n_parts_made = 0;
25 |   simcpp20::simulation<> &sim;
26 | 
27 | private:
28 |   simcpp20::process<> produce() {
29 |     while (true) {
30 |       double time_for_part = conf.time_for_part_dist(conf.gen);
31 | 
32 |       while (true) {
33 |         double start = sim.now();
34 |         auto timeout = sim.timeout(time_for_part);
35 |         co_await (timeout | failure);
36 | 
37 |         if (timeout.triggered()) {
38 |           // part is finished
39 |           ++n_parts_made;
40 |           break;
41 |         }
42 | 
43 |         // machine failed, calculate remaining time for part and wait for repair
44 |         time_for_part -= sim.now() - start;
45 |         co_await conf.repair_man.request();
46 |         co_await sim.timeout(conf.repair_time);
47 |         conf.repair_man.release();
48 |       }
49 |     }
50 |   }
51 | 
52 |   simcpp20::process<> fail() {
53 |     while (true) {
54 |       co_await sim.timeout(conf.time_to_failure_dist(conf.gen));
55 |       failure.trigger();
56 |       failure = sim.event();
57 |     }
58 |   }
59 | 
60 |   config &conf;
61 |   simcpp20::event<> failure;
62 | };
63 | 
64 | int main() {
65 |   simcpp20::simulation<> sim;
66 | 
67 |   std::random_device rd;
68 |   config conf{
69 |       .repair_time = 30,
70 |       .repair_man = simcpp20::resource{sim, 1},
71 |       .time_for_part_dist = std::normal_distribution<>{10, 2},
72 |       .time_to_failure_dist = std::exponential_distribution<>{1. / 300},
73 |       .gen = std::default_random_engine{rd()},
74 |   };
75 | 
76 |   int n_machines = 10;
77 |   std::vector<machine> machines;
78 |   machines.reserve(n_machines);
79 |   for (int i = 0; i < n_machines; ++i) {
80 |     machines.emplace_back(sim, conf);
81 |   }
82 | 
83 |   int n_weeks = 4;
84 |   sim.run_until(n_weeks * 7 * 24 * 60);
85 | 
86 |   printf("Machine shop results after %d weeks:\n", n_weeks);
87 |   int total = 0;
88 |   for (int i = 0; i < n_machines; ++i) {
89 |     printf("- Machine %d made %d parts\n", i, machines[i].n_parts_made);
90 |     total += machines[i].n_parts_made;
91 |   }
92 |   printf("Total: %d\n", total);
93 | }
94 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # SimCpp20
 2 | 
 3 | [![Linux](https://github.com/fschuetz04/simcpp20/actions/workflows/linux.yml/badge.svg)](https://github.com/fschuetz04/simcpp20/actions/workflows/linux.yml)
 4 | [![Windows](https://github.com/fschuetz04/simcpp20/actions/workflows/windows.yml/badge.svg)](https://github.com/fschuetz04/simcpp20/actions/workflows/windows.yml)
 5 | 
 6 | SimCpp20 is a discrete-event simulation framework for C++20.
 7 | It is similar to SimPy and aims to be easy to set up and use.
 8 | 
 9 | Processes are defined as functions receiving `simcpp20::simulation<> &` as their
10 | first argument and returning `simcpp20::process<>`.
11 | Each process is executed as a coroutine.
12 | Thus, this framework requires C++20.
13 | A short example simulating two clocks ticking in different time intervals looks like
14 | this:
15 | 
16 | ```c++
17 | #include <cstdio>
18 | 
19 | #include "fschuetz04/simcpp20.hpp"
20 | 
21 | simcpp20::process<> clock_proc(simcpp20::simulation<> &sim, char const *name,
22 |                              double delay) {
23 |   while (true) {
24 |     printf("[%.0f] %s\n", sim.now(), name);
25 |     co_await sim.timeout(delay);
26 |   }
27 | }
28 | 
29 | int main() {
30 |   simcpp20::simulation<> sim;
31 |   clock_proc(sim, "slow", 2);
32 |   clock_proc(sim, "fast", 1);
33 |   sim.run_until(5);
34 | }
35 | ```
36 | 
37 | When run, the following output is generated:
38 | 
39 | ```text
40 | [0] slow
41 | [0] fast
42 | [1] fast
43 | [2] slow
44 | [2] fast
45 | [3] fast
46 | [4] slow
47 | [4] fast
48 | ```
49 | 
50 | Other examples can be found in the `examples/` folder.
51 | 
52 | This project uses CMake.
53 | To build and execute the clocks example, run the following commands:
54 | 
55 | ```shell
56 | cmake -B build
57 | cmake --build build
58 | build/examples/clocks
59 | ```
60 | 
61 | The CMake configuration has been tested with GCC (version 10 or later), Clang (version
62 | 14 or later) and MSVC.
63 | If such a version is available under a different name (for example `g++-10`), you
64 | can try `CXX=g++-10 cmake -B build` instead of just `cmake -B build` to set the C++
65 | compiler command.
66 | When using an MSVC compiler, it must be of version 19.28 or later (Visual Studio
67 | 2019 version 16.8 or later).
68 | Contributions to improve compiler support are welcome!
69 | 
70 | If you want to use SimCpp20 in your project, the easiest option is to use CMake with
71 | FetchContent.
72 | A simple configuration looks like this:
73 | 
74 | ```cmake
75 | cmake_minimum_required(VERSION 3.14)
76 | 
77 | project(my_app)
78 | 
79 | include(FetchContent)
80 | 
81 | FetchContent_Declare(fschuetz04_simcpp20
82 |     GIT_REPOSITORY https://github.com/fschuetz04/simcpp20
83 |     GIT_TAG        ad975317db40d81dbe4c45c5db4edcd8ec6e2de8) # replace with latest revision
84 | 
85 | FetchContent_MakeAvailable(fschuetz04_simcpp20)
86 | 
87 | add_executable(app app.cpp)
88 | target_link_libraries(app PRIVATE fschuetz04::simcpp20)
89 | ```
90 | 
91 | Replace the commit hash with the latest commit hash of SimCpp20 accordingly.
92 | 
93 | ## License
94 | 
95 | Licensed under the MIT License.
96 | See the [licence file](LICENSE) for details.
97 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/value_event.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cassert> // assert
  4 | #include <memory>  // std::make_shared, std::shared_ptr
  5 | #include <utility> // std::forward, std::exchange
  6 | 
  7 | #include "event.hpp"
  8 | 
  9 | namespace simcpp20 {
 10 | 
 11 | /**
 12 |  * One event with a value.
 13 |  *
 14 |  * @tparam Time Type used for simulation time.
 15 |  * @tparam Value Type of the value.
 16 |  */
 17 | template <typename Value, class Time = double>
 18 | class value_event : public event<Time> {
 19 | public:
 20 |   /**
 21 |    * Constructor.
 22 |    *
 23 |    * @param simulation Reference to the simulation.
 24 |    */
 25 |   explicit value_event(simulation<Time> &sim)
 26 |       : event<Time>{std::make_shared<data>(sim)} {}
 27 | 
 28 |   /// Destructor.
 29 |   ~value_event() override = default;
 30 | 
 31 |   /**
 32 |    * Set the event state to triggered, and schedule it to be processed
 33 |    * immediately. If the event is not pending, nothing is done.
 34 |    *
 35 |    * @tparam Types of arguments to construct the event value with.
 36 |    * @param args Arguments to construct the event value with.
 37 |    */
 38 |   template <typename... Args> void trigger(Args &&...args) const {
 39 |     assert(event<Time>::data_);
 40 | 
 41 |     if (!event<Time>::pending()) {
 42 |       return;
 43 |     }
 44 | 
 45 |     set_value(std::forward<Args>(args)...);
 46 |     event<Time>::trigger();
 47 |   }
 48 | 
 49 |   /**
 50 |    * Called when a coroutine is resumed after using co_await on the event or if
 51 |    * the coroutine did not need to be suspended. The return value is the return
 52 |    * value of the co_await expression.
 53 |    *
 54 |    * @return Value of the event.
 55 |    */
 56 |   const Value &await_resume() {
 57 |     assert(event<Time>::data_);
 58 | 
 59 |     event<Time>::await_resume();
 60 |     return value();
 61 |   }
 62 | 
 63 |   /// @return Value of the event.
 64 |   const Value &value() const {
 65 |     assert(event<Time>::data_);
 66 | 
 67 |     auto casted_data = static_pointer_cast<data>(event<Time>::data_);
 68 |     return *casted_data->value_;
 69 |   }
 70 | 
 71 |   /**
 72 |    * Alias for simulation::any_of.
 73 |    *
 74 |    * @param other Other event.
 75 |    * @return New pending event which is triggered when this event or the other
 76 |    * event is processed.
 77 |    */
 78 |   value_event<Value, Time>
 79 |   operator|(const value_event<Value, Time> &other) const {
 80 |     assert(event<Time>::data_);
 81 |     return event<Time>::data_->sim_.template any_of<Value>(*this, other);
 82 |   }
 83 | 
 84 | private:
 85 |   /// Shared data of the event.
 86 |   class data : public event<Time>::data {
 87 |   public:
 88 |     using event<Time>::data::data;
 89 | 
 90 |     /// Destructor.
 91 |     ~data() override = default;
 92 | 
 93 |     /// Value of the event.
 94 |     std::shared_ptr<Value> value_;
 95 |   };
 96 | 
 97 |   /**
 98 |    * @tparam Args Types of arguments to construct the event value with.
 99 |    * @param args Arguments to construct the event value with.
100 |    */
101 |   template <typename... Args> void set_value(Args &&...args) const {
102 |     auto casted_data = static_pointer_cast<data>(event<Time>::data_);
103 |     casted_data->value_ = std::make_shared<Value>(std::forward<Args>(args)...);
104 |   }
105 | 
106 |   friend class simulation<Time>;
107 | };
108 | 
109 | } // namespace simcpp20
110 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/store.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cstddef> // size_t
  4 | #include <limits>  // std::numeric_limits
  5 | #include <queue>   // std::queue
  6 | 
  7 | #include "event.hpp"
  8 | #include "simulation.hpp"
  9 | #include "value_event.hpp"
 10 | 
 11 | namespace simcpp20 {
 12 | 
 13 | /**
 14 |  * A shared store holding objects.
 15 |  *
 16 |  * @tparam T Type of objects to store.
 17 |  * @tparam Time Type used for simulation time.
 18 |  */
 19 | template <typename T, typename Time = double> class store {
 20 | public:
 21 |   /**
 22 |    * Constructor.
 23 |    *
 24 |    * @param sim Reference to the simulation.
 25 |    * @param capacity Maximum number of items the store can hold. Defaults to
 26 |    * unlimited.
 27 |    */
 28 |   explicit store(simulation<Time> &sim,
 29 |                  size_t capacity = std::numeric_limits<size_t>::max())
 30 |       : sim_{sim}, capacity_{capacity} {}
 31 | 
 32 |   /**
 33 |    * Retrieve a value from the store.
 34 |    *
 35 |    * @return An event that will be triggered with the next value
 36 |    * from the store once it is available, which may be immediately.
 37 |    */
 38 |   value_event<T, Time> get() {
 39 |     auto ev = sim_.template event<T>();
 40 | 
 41 |     // add callback to trigger puts when this get is processed
 42 |     ev.add_callback([this]() { trigger_puts(); });
 43 | 
 44 |     // queue the get event
 45 |     gets_.push(ev);
 46 | 
 47 |     // try to match this get with an available value
 48 |     trigger_gets();
 49 | 
 50 |     return ev;
 51 |   }
 52 | 
 53 |   /**
 54 |    * Add a value to the store.
 55 |    *
 56 |    * @param value The value to add.
 57 |    * @return An event that will be triggered when the store has capacity and the
 58 |    * value is added to the store, which may be immediately.
 59 |    */
 60 |   event<Time> put(const T &value) {
 61 |     T copy = value;
 62 |     return put(std::move(copy));
 63 |   }
 64 | 
 65 |   /**
 66 |    * Add a value (via move) to the store.
 67 |    *
 68 |    * @param value The value to add.
 69 |    * @return An event that will be triggered when the store has capacity and the
 70 |    * value is added to the store, which may be immediately.
 71 |    */
 72 |   event<Time> put(T &&value) {
 73 |     auto ev = sim_.event();
 74 | 
 75 |     // add callback to trigger gets when this put is processed
 76 |     ev.add_callback([this]() { trigger_gets(); });
 77 | 
 78 |     // queue the put event
 79 |     puts_.emplace(ev, std::move(value));
 80 | 
 81 |     // try to process this put if there is capacity
 82 |     trigger_puts();
 83 | 
 84 |     return ev;
 85 |   }
 86 | 
 87 | private:
 88 |   /// Reference to the simulation.
 89 |   simulation<Time> &sim_;
 90 | 
 91 |   /// Values currently in the store.
 92 |   std::queue<T> values_;
 93 | 
 94 |   /// Capacity of the store.
 95 |   size_t capacity_;
 96 | 
 97 |   /// Pending get events.
 98 |   std::queue<value_event<T, Time>> gets_;
 99 | 
100 |   /// Pairs of pending put events and the values to be put into the store.
101 |   std::queue<std::pair<event<Time>, T>> puts_;
102 | 
103 |   /// Trigger pending get events until the store is empty.
104 |   void trigger_gets() {
105 |     while (!values_.empty() && !gets_.empty()) {
106 |       auto ev = std::move(gets_.front());
107 |       gets_.pop();
108 |       if (ev.aborted()) {
109 |         continue;
110 |       }
111 | 
112 |       ev.trigger(std::move(values_.front()));
113 |       values_.pop();
114 |     }
115 |   }
116 | 
117 |   /// Trigger pending put events until the store is full.
118 |   void trigger_puts() {
119 |     while (values_.size() < capacity_ && !puts_.empty()) {
120 |       auto [ev, value] = std::move(puts_.front());
121 |       puts_.pop();
122 |       if (ev.aborted()) {
123 |         continue;
124 |       }
125 | 
126 |       values_.emplace(std::move(value));
127 |       ev.trigger();
128 |     }
129 |   }
130 | };
131 | 
132 | } // namespace simcpp20
133 | 


--------------------------------------------------------------------------------
/tests/awaitable_tests.cpp:
--------------------------------------------------------------------------------
  1 | #include "catch2/catch_test_macros.hpp"
  2 | #include "fschuetz04/simcpp20.hpp"
  3 | 
  4 | simcpp20::process<> producer_process(simcpp20::simulation<> &sim, int delay) {
  5 |   co_await sim.timeout(delay);
  6 | }
  7 | 
  8 | template <typename A1, typename A2>
  9 | simcpp20::process<> consumer_process(simcpp20::simulation<> &sim, 
 10 |                                      A1 &a1, 
 11 |                                      A2 &a2,
 12 |                                      double &first_time,
 13 |                                      double &all_time) {
 14 |   // Wait for any producer to finish
 15 |   co_await (a1 | a2);
 16 |   first_time = sim.now();
 17 |   
 18 |   // Wait for all producers to finish
 19 |   co_await (a1 & a2);
 20 |   all_time = sim.now();
 21 | }
 22 | 
 23 | TEST_CASE("processes can be used with any_of and all_of") {
 24 |   simcpp20::simulation<> sim;
 25 | 
 26 |   // Test with process objects
 27 |   SECTION("process | process") {
 28 |     auto p1 = producer_process(sim, 5);
 29 |     auto p2 = producer_process(sim, 10);
 30 |     
 31 |     double first_time = -1;
 32 |     double all_time = -1;
 33 |     consumer_process(sim, p1, p2, first_time, all_time);
 34 |     
 35 |     sim.run();
 36 |     
 37 |     REQUIRE(first_time == 5);
 38 |     REQUIRE(all_time == 10);
 39 |   }
 40 |   
 41 |   // Test with mixing process and event
 42 |   SECTION("process | event") {
 43 |     auto p1 = producer_process(sim, 5);
 44 |     auto e2 = sim.timeout(10);
 45 |     
 46 |     double first_time = -1;
 47 |     double all_time = -1;
 48 |     consumer_process(sim, p1, e2, first_time, all_time);
 49 |     
 50 |     sim.run();
 51 |     
 52 |     REQUIRE(first_time == 5);
 53 |     REQUIRE(all_time == 10);
 54 |   }
 55 |   
 56 |   // Test with event objects
 57 |   SECTION("event | event using processes") {
 58 |     auto e1 = sim.timeout(5);
 59 |     auto e2 = sim.timeout(10);
 60 |     
 61 |     double first_time = -1;
 62 |     double all_time = -1;
 63 |     consumer_process(sim, e1, e2, first_time, all_time);
 64 |     
 65 |     sim.run();
 66 |     
 67 |     REQUIRE(first_time == 5);
 68 |     REQUIRE(all_time == 10);
 69 |   }
 70 | }
 71 | 
 72 | simcpp20::process<> callback_test_process(simcpp20::simulation<> &sim, int delay, bool &called) {
 73 |   co_await sim.timeout(delay);
 74 |   called = true;
 75 | }
 76 | 
 77 | TEST_CASE("awaitable callbacks work with processes") {
 78 |   simcpp20::simulation<> sim;
 79 | 
 80 |   SECTION("process callbacks are called on completion") {
 81 |     bool callback_called = false;
 82 |     auto p = callback_test_process(sim, 5, callback_called);
 83 |     
 84 |     bool manual_callback_called = false;
 85 |     p.add_callback([&manual_callback_called]() {
 86 |       manual_callback_called = true;
 87 |     });
 88 |     
 89 |     sim.run();
 90 |     
 91 |     REQUIRE(callback_called);
 92 |     REQUIRE(manual_callback_called);
 93 |   }
 94 | }
 95 | 
 96 | // Test composite operations with multiple process objects
 97 | TEST_CASE("complex process compositions with any_of and all_of") {
 98 |   simcpp20::simulation<> sim;
 99 |   
100 |   SECTION("complex composition") {
101 |     auto p1 = producer_process(sim, 5);
102 |     auto p2 = producer_process(sim, 10);
103 |     auto p3 = producer_process(sim, 15);
104 |     
105 |     // Any of p1 or p2, then all of those and p3
106 |     auto any12 = p1 | p2;
107 |     auto all_events = any12 & p3;
108 |     
109 |     double completion_time = -1;
110 |     
111 |     // Define a lambda that returns a process
112 |     auto wait_fn = [&completion_time](simcpp20::simulation<>& s, simcpp20::event<>& ev) -> simcpp20::process<> {
113 |       co_await ev;
114 |       completion_time = s.now();
115 |     };
116 |     
117 |     // Call the lambda with sim and the composed event
118 |     wait_fn(sim, all_events);
119 |     
120 |     sim.run();
121 |     
122 |     // The first of p1 or p2 completes at t=5, then we wait for both p2 and p3
123 |     // p2 completes at t=10, p3 completes at t=15, so the final time should be 15
124 |     REQUIRE(completion_time == 15);
125 |   }
126 | }


--------------------------------------------------------------------------------
/tests/resource_tests.cpp:
--------------------------------------------------------------------------------
  1 | #include "catch2/catch_test_macros.hpp"
  2 | #include "fschuetz04/simcpp20.hpp"
  3 | 
  4 | #include <vector> // std::vector
  5 | 
  6 | TEST_CASE("resource basics") {
  7 |   simcpp20::simulation<> sim;
  8 | 
  9 |   SECTION("resource can be created with initial available count") {
 10 |     simcpp20::resource res(sim, 3);
 11 |     REQUIRE(res.available() == 3);
 12 |   }
 13 | 
 14 |   SECTION("requesting and releasing resources") {
 15 |     simcpp20::resource res(sim, 2);
 16 | 
 17 |     // request first resource
 18 |     auto req1 = res.request();
 19 |     REQUIRE(res.available() == 1);
 20 | 
 21 |     // request second resource
 22 |     auto req2 = res.request();
 23 |     REQUIRE(res.available() == 0);
 24 | 
 25 |     // release first resource
 26 |     res.release();
 27 |     REQUIRE(res.available() == 1);
 28 | 
 29 |     // release second resource
 30 |     res.release();
 31 |     REQUIRE(res.available() == 2);
 32 |   }
 33 | }
 34 | 
 35 | simcpp20::process<> resource_user(simcpp20::simulation<> &sim,
 36 |                                   simcpp20::resource<> &res, double use_time,
 37 |                                   std::vector<double> &usage_times) {
 38 |   // request the resource
 39 |   co_await res.request();
 40 | 
 41 |   // record when we got the resource
 42 |   usage_times.push_back(sim.now());
 43 | 
 44 |   // use the resource for some time
 45 |   co_await sim.timeout(use_time);
 46 | 
 47 |   // release the resource
 48 |   res.release();
 49 | }
 50 | 
 51 | TEST_CASE("resource queuing behavior") {
 52 |   simcpp20::simulation<> sim;
 53 |   std::vector<double> usage_times;
 54 | 
 55 |   SECTION("processes queue for limited resources") {
 56 |     simcpp20::resource res(sim, 1);
 57 | 
 58 |     // start three processes that want to use the resource
 59 |     // t=0, uses until t=10
 60 |     resource_user(sim, res, 10, usage_times);
 61 |     // queued, gets resource at t=10, uses until t=15
 62 |     resource_user(sim, res, 5, usage_times);
 63 |     // queued, gets resource at t=15, uses until t=18
 64 |     resource_user(sim, res, 3, usage_times);
 65 | 
 66 |     sim.run();
 67 | 
 68 |     REQUIRE(usage_times == std::vector<double>{0, 10, 15});
 69 |   }
 70 | 
 71 |   SECTION("multiple resources can serve multiple processes") {
 72 |     simcpp20::resource res(sim, 2);
 73 | 
 74 |     // Start three processes that want to use the resource
 75 |     // t=0, uses until t=10
 76 |     resource_user(sim, res, 10, usage_times);
 77 |     // t=0, uses until t=15
 78 |     resource_user(sim, res, 15, usage_times);
 79 |     // queued, gets resource at t=10, uses until t=15
 80 |     resource_user(sim, res, 5, usage_times);
 81 | 
 82 |     sim.run();
 83 | 
 84 |     REQUIRE(usage_times == std::vector<double>{0, 0, 10});
 85 |   }
 86 | }
 87 | 
 88 | TEST_CASE("resource with aborted requests") {
 89 |   simcpp20::simulation<> sim;
 90 |   std::vector<double> usage_times;
 91 | 
 92 |   SECTION("process with timeout can abort resource request") {
 93 |     simcpp20::resource res(sim, 1);
 94 |     bool second_timed_out = false;
 95 | 
 96 |     // t=0, uses until t=10
 97 |     resource_user(sim, res, 10, usage_times);
 98 | 
 99 |     // queued, gives up after waiting until t=5
100 |     auto proc = [&res, &usage_times,
101 |                  &second_timed_out](auto &sim) -> simcpp20::process<> {
102 |       auto request = res.request();
103 |       auto timeout = sim.timeout(5);
104 | 
105 |       co_await (request | timeout);
106 | 
107 |       if (request.triggered()) {
108 |         // got the resource
109 |         usage_times.push_back(sim.now());
110 |         co_await sim.timeout(5);
111 |         res.release();
112 |       } else {
113 |         // timed out waiting
114 |         second_timed_out = true;
115 |         request.abort();
116 |       }
117 |     };
118 | 
119 |     proc(sim);
120 | 
121 |     // queued, gets resource at t=10, uses until t=15
122 |     resource_user(sim, res, 5, usage_times);
123 | 
124 |     sim.run();
125 | 
126 |     REQUIRE(second_timed_out);
127 |     REQUIRE(usage_times == std::vector<double>{0, 10});
128 |   }
129 | }
130 | 


--------------------------------------------------------------------------------
/tests/tests.cpp:
--------------------------------------------------------------------------------
  1 | #include "catch2/catch_test_macros.hpp"
  2 | #include "catch2/generators/catch_generators.hpp"
  3 | #include "fschuetz04/simcpp20.hpp"
  4 | 
  5 | #include <string> // std::string
  6 | 
  7 | simcpp20::process<> awaiter(simcpp20::simulation<> &sim, simcpp20::event<> ev,
  8 |                             double expected_time, bool &finished) {
  9 |   REQUIRE(sim.now() == 0);
 10 |   co_await ev;
 11 |   REQUIRE(sim.now() == expected_time);
 12 |   finished = true;
 13 | };
 14 | 
 15 | simcpp20::process<> ref_awaiter(simcpp20::simulation<> &sim,
 16 |                                 simcpp20::event<> &ev, double expected_time,
 17 |                                 bool &finished) {
 18 |   REQUIRE(sim.now() == 0);
 19 |   co_await ev;
 20 |   REQUIRE(sim.now() == expected_time);
 21 |   finished = true;
 22 | }
 23 | 
 24 | TEST_CASE("an aborted process does not run") {
 25 |   simcpp20::simulation<> sim;
 26 | 
 27 |   auto ev = sim.timeout(1);
 28 |   bool finished = false;
 29 |   auto process_ev = awaiter(sim, ev, -1, finished);
 30 |   process_ev.abort();
 31 | 
 32 |   sim.run();
 33 | 
 34 |   REQUIRE(!finished);
 35 | }
 36 | 
 37 | TEST_CASE("multiple processes can await the same event reference") {
 38 |   simcpp20::simulation<> sim;
 39 | 
 40 |   auto ev = sim.timeout(1);
 41 |   bool finished_a = false;
 42 |   ref_awaiter(sim, ev, 1, finished_a);
 43 |   bool finished_b = false;
 44 |   ref_awaiter(sim, ev, 1, finished_b);
 45 | 
 46 |   sim.run();
 47 | 
 48 |   REQUIRE(finished_a);
 49 |   REQUIRE(finished_b);
 50 | }
 51 | 
 52 | TEST_CASE("any_of") {
 53 |   simcpp20::simulation<> sim;
 54 | 
 55 |   SECTION("any_of is not triggered when all events are never processed") {
 56 |     auto ev = sim.any_of(sim.event(), sim.event());
 57 |     bool finished = false;
 58 |     awaiter(sim, ev, -1, finished);
 59 | 
 60 |     sim.run();
 61 | 
 62 |     REQUIRE(!finished);
 63 |   }
 64 | 
 65 |   double a = GENERATE(1, 2);
 66 |   auto ev_a = sim.timeout(a);
 67 |   auto ev_b = sim.timeout(3 - a);
 68 | 
 69 |   SECTION("any_of is triggered when the first event is processed") {
 70 |     auto ev = sim.any_of(ev_a, ev_b);
 71 |     bool finished = false;
 72 |     awaiter(sim, ev, 1, finished);
 73 | 
 74 |     sim.run();
 75 | 
 76 |     REQUIRE(finished);
 77 |   }
 78 | 
 79 |   SECTION("| is an alias for any_of") {
 80 |     auto ev = ev_a | ev_b;
 81 |     bool finished = false;
 82 |     awaiter(sim, ev, 1, finished);
 83 | 
 84 |     sim.run();
 85 | 
 86 |     REQUIRE(finished);
 87 |   }
 88 | }
 89 | 
 90 | template <typename Value>
 91 | simcpp20::process<>
 92 | value_awaiter(simcpp20::simulation<> &sim, simcpp20::value_event<Value> ev,
 93 |               Value expected_value, double expected_time, bool &finished) {
 94 |   REQUIRE(sim.now() == 0);
 95 |   Value value = co_await ev;
 96 |   REQUIRE(value == expected_value);
 97 |   REQUIRE(sim.now() == expected_time);
 98 |   finished = true;
 99 | };
100 | 
101 | TEST_CASE("any_of with value_event") {
102 |   simcpp20::simulation<> sim;
103 | 
104 |   double delay_a = GENERATE(1, 2);
105 |   std::string value_a = "a";
106 |   auto ev_a = sim.timeout<std::string>(delay_a, value_a);
107 |   std::string value_b = "b";
108 |   auto ev_b = sim.timeout<std::string>(3 - delay_a, value_b);
109 | 
110 |   SECTION("any_of is triggered when the first event is processed") {
111 |     auto ev = sim.any_of<std::string>(ev_a, ev_b);
112 |     auto expected_value = delay_a == 1 ? value_a : value_b;
113 |     bool finished = false;
114 |     value_awaiter(sim, ev, expected_value, 1, finished);
115 | 
116 |     sim.run();
117 | 
118 |     REQUIRE(finished);
119 |   }
120 | 
121 |   SECTION("| is an alias for any_of") {
122 |     auto ev = ev_a | ev_b;
123 |     auto expected_value = delay_a == 1 ? value_a : value_b;
124 |     bool finished = false;
125 |     value_awaiter(sim, ev, expected_value, 1, finished);
126 | 
127 |     sim.run();
128 | 
129 |     REQUIRE(finished);
130 |   }
131 | }
132 | 
133 | TEST_CASE("all_of") {
134 |   simcpp20::simulation<> sim;
135 | 
136 |   SECTION("all_of is not triggered when one event is never processed") {
137 |     auto ev = sim.all_of(sim.timeout(1), sim.event());
138 |     bool finished = false;
139 |     awaiter(sim, ev, -1, finished);
140 | 
141 |     sim.run();
142 | 
143 |     REQUIRE(!finished);
144 |   }
145 | 
146 |   double delay_a = GENERATE(1, 2);
147 |   auto ev_a = sim.timeout(delay_a);
148 |   auto ev_b = sim.timeout(3 - delay_a);
149 | 
150 |   SECTION("all_of is triggered when all events are processed") {
151 |     auto ev = sim.all_of(ev_a, ev_b);
152 |     bool finished = false;
153 |     awaiter(sim, ev, 2, finished);
154 | 
155 |     sim.run();
156 | 
157 |     REQUIRE(finished);
158 |   }
159 | 
160 |   SECTION("& is an alias for all_of") {
161 |     auto ev = ev_a & ev_b;
162 |     bool finished = false;
163 |     awaiter(sim, ev, 2, finished);
164 | 
165 |     sim.run();
166 | 
167 |     REQUIRE(finished);
168 |   }
169 | }
170 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/process.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cassert>    // assert
  4 | #include <coroutine>  // std::coroutine_handle
  5 | #include <functional> // std::function
  6 | 
  7 | #include "awaitable.hpp"
  8 | #include "event.hpp"
  9 | #include "promise_type.hpp"
 10 | 
 11 | namespace simcpp20 {
 12 | 
 13 | template <typename Time> class simulation;
 14 | template <typename Value, typename Time> class value_process;
 15 | 
 16 | /**
 17 |  * A running process (coroutine) that can be awaited.
 18 |  *
 19 |  * @tparam Time Type used for simulation time.
 20 |  */
 21 | template <typename Time = double> class process : public awaitable {
 22 | public:
 23 |   /**
 24 |    * Constructor.
 25 |    *
 26 |    * @param simulation Reference to the simulation.
 27 |    */
 28 |   explicit process(simulation<Time> &sim) : event_{sim} {}
 29 | 
 30 |   /**
 31 |    * Abort the process.
 32 |    */
 33 |   void abort() const { event_.abort(); }
 34 | 
 35 |   /// @return Whether the process is pending.
 36 |   bool pending() const override { return event_.pending(); }
 37 | 
 38 |   /// @return Whether the process is triggered or processed.
 39 |   bool triggered() const override { return event_.triggered(); }
 40 | 
 41 |   /// @return Whether the process is processed.
 42 |   bool processed() const override { return event_.processed(); }
 43 | 
 44 |   /// @return Whether the process is aborted.
 45 |   bool aborted() const override { return event_.aborted(); }
 46 | 
 47 |   /**
 48 |    * Add a callback to be called when the awaitable is processed.
 49 |    *
 50 |    * @param cb Callback.
 51 |    */
 52 |   void add_callback(std::function<void()> cb) const override {
 53 |     event_.add_callback(cb);
 54 |   }
 55 | 
 56 |   /**
 57 |    * Called when using co_await on the process. The calling coroutine is only
 58 |    * suspended if this method returns false.
 59 |    *
 60 |    * @return Whether the process is processed.
 61 |    */
 62 |   bool await_ready() const { return event_.processed(); }
 63 | 
 64 |   /**
 65 |    * Called when a coroutine is suspended after using co_await on the process.
 66 |    *
 67 |    * @tparam Promise Promise type of the coroutine.
 68 |    * @param handle Coroutine handle.
 69 |    */
 70 |   template <typename Promise>
 71 |   void await_suspend(std::coroutine_handle<Promise> handle) {
 72 |     event_.await_suspend(handle);
 73 |   }
 74 | 
 75 |   /**
 76 |    * Called when a coroutine is resumed after using co_await on the process or
 77 |    * if the coroutine did not need to be suspended.
 78 |    */
 79 |   void await_resume() { event_.await_resume(); }
 80 | 
 81 |   // TODO: remove?
 82 |   // Make value_process able to access the process internals
 83 |   template <typename Value, typename T> friend class value_process;
 84 | 
 85 |   // Make simulation able to access protected methods
 86 |   friend class simulation<Time>;
 87 | 
 88 |   /**
 89 |    * Alias for simulation::any_of.
 90 |    *
 91 |    * @param other Other awaitable.
 92 |    * @return New pending event which is triggered when this process or the other
 93 |    * awaitable is processed.
 94 |    */
 95 |   template <typename Awaitable>
 96 |   event<Time> operator|(const Awaitable &other) const {
 97 |     return event_ | other;
 98 |   }
 99 | 
100 |   /**
101 |    * Alias for simulation::all_of.
102 |    *
103 |    * @param other Other awaitable.
104 |    * @return New pending event which is triggered when this process and the
105 |    * other awaitable are processed.
106 |    */
107 |   template <typename Awaitable>
108 |   event<Time> operator&(const Awaitable &other) const {
109 |     return event_ & other;
110 |   }
111 | 
112 | protected:
113 |   /**
114 |    * Trigger the process.
115 |    * This method is protected to prevent direct calls from user code.
116 |    */
117 |   void trigger() const { event_.trigger(); }
118 | 
119 |   /// Internal event used to implement process behavior
120 |   event<Time> event_;
121 | 
122 | private:
123 |   using generic_promise_type = internal::generic_promise_type<Time>;
124 | 
125 | public:
126 |   /// Promise type for a coroutine returning a process.
127 |   class promise_type : public generic_promise_type {
128 |   public:
129 |     using handle_type = std::coroutine_handle<promise_type>;
130 | 
131 |     /**
132 |      * Constructor.
133 |      *
134 |      * @tparam Args Types of additional arguments passed to the coroutine
135 |      * function.
136 |      * @param sim Reference to the simulation.
137 |      */
138 |     template <typename... Args>
139 |     explicit promise_type(simulation<Time> &sim, Args &&...)
140 |         : generic_promise_type{sim, handle_type::from_promise(*this)},
141 |           proc_{sim} {}
142 | 
143 |     /**
144 |      * Constructor.
145 |      *
146 |      * @tparam Class Class type if the coroutine function is a lambda or a
147 |      * member function of a class.
148 |      * @tparam Args Types of additional arguments passed to the coroutine
149 |      * function.
150 |      * @param sim Reference to the simulation.
151 |      */
152 |     template <typename Class, typename... Args>
153 |     explicit promise_type(Class &&, simulation<Time> &sim, Args &&...)
154 |         : generic_promise_type{sim, handle_type::from_promise(*this)},
155 |           proc_{sim} {}
156 | 
157 |     /**
158 |      * Constructor.
159 |      *
160 |      * @tparam Class Class type if the coroutine function is a member function
161 |      * of a class. Must contain a member variable sim referencing the simulation
162 |      * instance.
163 |      * @tparam Args Types of additional arguments passed to the coroutine
164 |      * function.
165 |      * @param c Class instance.
166 |      */
167 |     template <typename Class, typename... Args>
168 |     explicit promise_type(Class &&c, Args &&...)
169 |         : generic_promise_type{c.sim, handle_type::from_promise(*this)},
170 |           proc_{c.sim} {}
171 | 
172 | #ifdef __INTELLISENSE__
173 |     // IntelliSense fix. See https://stackoverflow.com/q/67209981.
174 |     promise_type();
175 | #endif
176 | 
177 |     /// Destructor.
178 |     ~promise_type() override = default;
179 | 
180 |     /// @return Whether this process is aborted.
181 |     bool is_aborted() const override { return proc_.aborted(); }
182 | 
183 |     /**
184 |      * Called to get the return value of the coroutine function.
185 |      *
186 |      * @return Process associated with the coroutine. This process acts like an
187 |      * event which is triggered when the coroutine returns.
188 |      */
189 |     process<Time> get_return_object() const { return proc_; }
190 | 
191 |     /**
192 |      * Called when the coroutine returns. Trigger the process associated with
193 |      * the coroutine.
194 |      */
195 |     void return_void() const { proc_.trigger(); }
196 | 
197 |     /**
198 |      * Process associated with the coroutine. This process acts like an event
199 |      * which is triggered when the coroutine returns.
200 |      */
201 |     process<Time> proc_;
202 |   };
203 | };
204 | 
205 | } // namespace simcpp20
206 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/value_process.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <coroutine>  // std::coroutine_handle
  4 | #include <functional> // std::function
  5 | #include <utility>    // std::forward
  6 | 
  7 | #include "process.hpp"
  8 | #include "promise_type.hpp"
  9 | #include "value_event.hpp"
 10 | 
 11 | namespace simcpp20 {
 12 | 
 13 | template <typename Time> class simulation;
 14 | 
 15 | /**
 16 |  * A running process (coroutine) that returns a value when it completes. Like
 17 |  * process<>, it can be awaited.
 18 |  *
 19 |  * @tparam Value Type of the value returned when the process completes.
 20 |  * @tparam Time Type used for simulation time.
 21 |  */
 22 | template <typename Value, typename Time = double> class value_process {
 23 | public:
 24 |   /**
 25 |    * Constructor.
 26 |    *
 27 |    * @param simulation Reference to the simulation.
 28 |    */
 29 |   explicit value_process(simulation<Time> &sim) : event_{sim} {}
 30 | 
 31 |   /**
 32 |    * Abort the process.
 33 |    */
 34 |   void abort() const { event_.abort(); }
 35 | 
 36 |   /**
 37 |    * Check if the process is pending.
 38 |    *
 39 |    * @return Whether the process is pending.
 40 |    */
 41 |   bool pending() const { return event_.pending(); }
 42 | 
 43 |   /**
 44 |    * Check if the process is triggered or processed.
 45 |    *
 46 |    * @return Whether the process is triggered or processed.
 47 |    */
 48 |   bool triggered() const { return event_.triggered(); }
 49 | 
 50 |   /**
 51 |    * Check if the process is processed.
 52 |    *
 53 |    * @return Whether the process is processed.
 54 |    */
 55 |   bool processed() const { return event_.processed(); }
 56 | 
 57 |   /**
 58 |    * Check if the process is aborted.
 59 |    *
 60 |    * @return Whether the process is aborted.
 61 |    */
 62 |   bool aborted() const { return event_.aborted(); }
 63 | 
 64 |   /**
 65 |    * Add a callback to be called when the process is processed.
 66 |    *
 67 |    * @param cb Callback to be called when the process is processed.
 68 |    */
 69 |   void add_callback(std::function<void()> cb) const { event_.add_callback(cb); }
 70 | 
 71 |   /**
 72 |    * Called when using co_await on the process. The calling coroutine is only
 73 |    * suspended if this method returns false.
 74 |    *
 75 |    * @return Whether the process is processed.
 76 |    */
 77 |   bool await_ready() const { return event_.processed(); }
 78 | 
 79 |   /**
 80 |    * Called when a coroutine is suspended after using co_await on the process.
 81 |    *
 82 |    * @tparam Promise Promise type of the coroutine.
 83 |    * @param handle Coroutine handle.
 84 |    */
 85 |   template <typename Promise>
 86 |   void await_suspend(std::coroutine_handle<Promise> handle) {
 87 |     event_.await_suspend(handle);
 88 |   }
 89 | 
 90 |   /**
 91 |    * Called when a coroutine is resumed after using co_await on the process or
 92 |    * if the coroutine did not need to be suspended.
 93 |    *
 94 |    * @return The value returned by the process.
 95 |    */
 96 |   Value await_resume() { return event_.value(); }
 97 | 
 98 |   /**
 99 |    * Get the value of the process.
100 |    * @return The value of the process.
101 |    */
102 |   const Value &value() const { return event_.value(); }
103 | 
104 |   /**
105 |    * Value processes can only be triggered by the framework internally, not by
106 |    * user code. Value processes are triggered automatically when the coroutine
107 |    * finishes.
108 |    */
109 |   friend class promise_type;
110 |   // Make simulation able to access protected methods
111 |   friend class simulation<Time>;
112 | 
113 | protected:
114 |   /**
115 |    * Trigger the process with a value.
116 |    * This method is protected to prevent direct calls from user code.
117 |    */
118 |   template <typename... Args> void trigger(Args &&...args) const {
119 |     event_.trigger(std::forward<Args>(args)...);
120 |   }
121 | 
122 |   /**
123 |    * Get the internal event.
124 |    * This method is protected to prevent direct access from user code.
125 |    */
126 |   const value_event<Value, Time> &get_event() const { return event_; }
127 | 
128 |   /// Internal event used to implement process behavior
129 |   value_event<Value, Time> event_;
130 | 
131 | private:
132 |   using generic_promise_type = internal::generic_promise_type<Time>;
133 | 
134 | public:
135 |   /// Promise type for a coroutine returning a value_process.
136 |   class promise_type : public generic_promise_type {
137 |   public:
138 |     using handle_type = std::coroutine_handle<promise_type>;
139 | 
140 |     /**
141 |      * Constructor.
142 |      *
143 |      * @tparam Args Types of additional arguments passed to the coroutine
144 |      * function.
145 |      * @param sim Reference to the simulation.
146 |      */
147 |     template <typename... Args>
148 |     explicit promise_type(simulation<Time> &sim, Args &&...)
149 |         : generic_promise_type{sim, handle_type::from_promise(*this)},
150 |           proc_{sim} {}
151 | 
152 |     /**
153 |      * Constructor.
154 |      *
155 |      * @tparam Class Class type if the coroutine function is a lambda or a
156 |      * member function of a class.
157 |      * @tparam Args Types of additional arguments passed to the coroutine
158 |      * function.
159 |      * @param sim Reference to the simulation.
160 |      */
161 |     template <typename Class, typename... Args>
162 |     explicit promise_type(Class &&, simulation<Time> &sim, Args &&...)
163 |         : generic_promise_type{sim, handle_type::from_promise(*this)},
164 |           proc_{sim} {}
165 | 
166 |     /**
167 |      * Constructor.
168 |      *
169 |      * @tparam Class Class type if the coroutine function is a member function
170 |      * of a class. Must contain a member variable sim referencing the simulation
171 |      * instance.
172 |      * @tparam Args Types of additional arguments passed to the coroutine
173 |      * function.
174 |      * @param c Class instance.
175 |      */
176 |     template <typename Class, typename... Args>
177 |     explicit promise_type(Class &&c, Args &&...)
178 |         : generic_promise_type{c.sim, handle_type::from_promise(*this)},
179 |           proc_{c.sim} {}
180 | 
181 | #ifdef __INTELLISENSE__
182 |     // IntelliSense fix. See https://stackoverflow.com/q/67209981.
183 |     promise_type();
184 | #endif
185 | 
186 |     /// Destructor.
187 |     ~promise_type() override = default;
188 | 
189 |     /// @return Whether this process is aborted.
190 |     bool is_aborted() const override { return proc_.aborted(); }
191 | 
192 |     /**
193 |      * Called to get the return value of the coroutine function.
194 |      *
195 |      * @return Process associated with the coroutine. This process acts like
196 |      * an event triggered when the coroutine returns.
197 |      */
198 |     value_process<Value, Time> get_return_object() const { return proc_; }
199 | 
200 |     /**
201 |      * Called when the coroutine returns. Trigger the process associated with
202 |      * the coroutine with the returned value.
203 |      *
204 |      * @tparam Args Types of arguments to construct the return value with.
205 |      * @param args Arguments to construct the return value with.
206 |      */
207 |     template <typename... Args> void return_value(Args &&...args) const {
208 |       proc_.trigger(std::forward<Args>(args)...);
209 |     }
210 | 
211 |     /**
212 |      * Value process associated with the coroutine. This process acts like an
213 |      * event triggered when the coroutine returns with the value the coroutine
214 |      * returns.
215 |      */
216 |     value_process<Value, Time> proc_;
217 |   };
218 | };
219 | 
220 | } // namespace simcpp20
221 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/event.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cassert>    // assert
  4 | #include <coroutine>  // std::coroutine_handle, std::suspend_never
  5 | #include <cstddef>    // std::size_t
  6 | #include <functional> // std::function, std::hash
  7 | #include <memory>     // std::shared_ptr, std::make_shared
  8 | #include <utility>    // std::exchange, std::move
  9 | #include <vector>     // std::vector
 10 | 
 11 | #include "awaitable.hpp"
 12 | #include "promise_type.hpp"
 13 | 
 14 | namespace simcpp20 {
 15 | 
 16 | template <typename Time> class simulation;
 17 | template <typename Time> class process;
 18 | 
 19 | /**
 20 |  * An event that can be awaited, triggered, and aborted.
 21 |  *
 22 |  * @tparam Time Type used for simulation time.
 23 |  */
 24 | template <typename Time = double> class event : public awaitable {
 25 | public:
 26 |   /**
 27 |    * Constructor.
 28 |    *
 29 |    * @param simulation Reference to the simulation.
 30 |    */
 31 |   explicit event(simulation<Time> &sim) : data_{std::make_shared<data>(sim)} {}
 32 | 
 33 |   /// Destructor.
 34 |   virtual ~event() = default;
 35 | 
 36 |   /**
 37 |    * Copy constructor.
 38 |    *
 39 |    * @param other Event to copy.
 40 |    */
 41 |   event(const event &other) : data_{other.data_} { assert(data_); }
 42 | 
 43 |   /**
 44 |    * Move constructor.
 45 |    *
 46 |    * @param other Event to move.
 47 |    */
 48 |   event(event &&other) noexcept : data_{std::move(other.data_)} {
 49 |     assert(data_);
 50 |   }
 51 | 
 52 |   /**
 53 |    * Copy assignment operator.
 54 |    *
 55 |    * @param other Event to replace this event with.
 56 |    * @return Reference to this instance.
 57 |    */
 58 |   event &operator=(const event &other) {
 59 |     data_ = other.data_;
 60 |     assert(data_);
 61 |     return *this;
 62 |   }
 63 | 
 64 |   /**
 65 |    * Move assignment operator.
 66 |    *
 67 |    * @param other Event to replace this event with.
 68 |    * @return Reference to this instance.
 69 |    */
 70 |   event &operator=(event &&other) noexcept {
 71 |     data_ = std::move(other.data_);
 72 |     assert(data_);
 73 |     return *this;
 74 |   }
 75 | 
 76 |   /**
 77 |    * Set the event state to triggered and schedule it to be processed
 78 |    * immediately. If the event is not pending, nothing is done.
 79 |    */
 80 |   void trigger() const {
 81 |     assert(data_);
 82 | 
 83 |     if (!pending()) {
 84 |       return;
 85 |     }
 86 | 
 87 |     data_->sim_.schedule(*this);
 88 |     data_->state_ = state::triggered;
 89 |   }
 90 | 
 91 |   /**
 92 |    * Set the event state to aborted. If the event is not pending, nothing is
 93 |    * done.
 94 |    */
 95 |   void abort() const {
 96 |     assert(data_);
 97 | 
 98 |     if (!pending()) {
 99 |       return;
100 |     }
101 | 
102 |     data_->state_ = state::aborted;
103 | 
104 |     data_->cbs_.clear();
105 | 
106 |     std::vector<internal::generic_promise_type<Time> *> temp_promises;
107 |     data_->promises_.swap(temp_promises);
108 |     for (auto &promise : temp_promises) {
109 |       promise->process_handle().destroy();
110 |     }
111 |   }
112 | 
113 |   /**
114 |    * Add a callback to be called when the awaitable is processed.
115 |    *
116 |    * @param cb Callback.
117 |    */
118 |   void add_callback(std::function<void()> cb) const override {
119 |     assert(data_);
120 | 
121 |     if (processed() || aborted()) {
122 |       return;
123 |     }
124 | 
125 |     data_->cbs_.emplace_back(cb);
126 |   }
127 | 
128 |   /// @return Whether the event is pending.
129 |   bool pending() const override {
130 |     assert(data_);
131 |     return data_->state_ == state::pending;
132 |   }
133 | 
134 |   /// @return Whether the event is triggered or processed.
135 |   bool triggered() const override {
136 |     assert(data_);
137 |     return data_->state_ == state::triggered || processed();
138 |   }
139 | 
140 |   /// @return Whether the event is processed.
141 |   bool processed() const override {
142 |     assert(data_);
143 |     return data_->state_ == state::processed;
144 |   }
145 | 
146 |   /// @return Whether the event is aborted.
147 |   bool aborted() const override {
148 |     assert(data_);
149 |     return data_->state_ == state::aborted;
150 |   }
151 | 
152 |   /**
153 |    * Called when using co_await on the event. The calling coroutine is only
154 |    * suspended if this method returns false.
155 |    *
156 |    * @return Whether the event is processed.
157 |    */
158 |   bool await_ready() const {
159 |     assert(data_);
160 |     return processed();
161 |   }
162 | 
163 |   /**
164 |    * Called when a coroutine is suspended after using co_await on the event.
165 |    *
166 |    * @tparam Promise Promise type of the coroutine.
167 |    * @param handle Coroutine handle.
168 |    */
169 |   template <typename Promise>
170 |   void await_suspend(std::coroutine_handle<Promise> handle) {
171 |     assert(data_);
172 | 
173 |     if (aborted()) {
174 |       handle.destroy();
175 |       return;
176 |     }
177 | 
178 |     data_->promises_.push_back(&handle.promise());
179 |   }
180 | 
181 |   /**
182 |    * Called when a coroutine is resumed after using co_await on the event or if
183 |    * the coroutine did not need to be suspended.
184 |    */
185 |   void await_resume() { assert(data_); }
186 | 
187 |   /**
188 |    * Alias for simulation::any_of.
189 |    *
190 |    * @param other Other awaitable.
191 |    * @return New pending event which is triggered when this event or the other
192 |    * awaitable is processed.
193 |    */
194 |   event<Time> operator|(const awaitable &other) const {
195 |     assert(data_);
196 |     return data_->sim_.any_of(*this, other);
197 |   }
198 | 
199 |   /**
200 |    * Alias for simulation::all_of.
201 |    *
202 |    * @param other Other awaitable.
203 |    * @return New pending event which is triggered when this event and the other
204 |    * awaitable are processed.
205 |    */
206 |   template <typename Awaitable>
207 |   event<Time> operator&(const Awaitable &other) const {
208 |     assert(data_);
209 |     return data_->sim_.all_of(*this, other);
210 |   }
211 | 
212 |   /** Comparison operator.
213 |    *
214 |    * @param other Other event.
215 |    * @return Whether this event is equal to the other event.
216 |    */
217 |   bool operator==(const event<Time> &other) const {
218 |     return data_ == other.data_;
219 |   }
220 | 
221 | protected:
222 |   /**
223 |    * Set the event state to processed, resume all coroutines awaiting this
224 |    * event, and call all callbacks added to the event.
225 |    */
226 |   void process() const {
227 |     assert(data_);
228 | 
229 |     if (processed() || aborted()) {
230 |       return;
231 |     }
232 | 
233 |     data_->state_ = state::processed;
234 | 
235 |     std::vector<internal::generic_promise_type<Time> *> temp_promises;
236 |     data_->promises_.swap(temp_promises);
237 |     for (auto &promise : temp_promises) {
238 |       if (promise->is_aborted()) {
239 |         promise->process_handle().destroy();
240 |       } else {
241 |         promise->process_handle().resume();
242 |       }
243 |     }
244 | 
245 |     for (auto &cb : data_->cbs_) {
246 |       cb();
247 |     }
248 |     data_->cbs_.clear();
249 |   }
250 | 
251 |   /// State of the event.
252 |   enum class state {
253 |     /// Event is not yet triggered or aborted.
254 |     pending,
255 | 
256 |     /// Event is triggered and will be processed at the current simulation time.
257 |     triggered,
258 | 
259 |     /// Event is processed.
260 |     processed,
261 | 
262 |     /// Event is aborted.
263 |     aborted
264 |   };
265 | 
266 |   /// Shared data of the event.
267 |   class data {
268 |   public:
269 |     /**
270 |      * Constructor.
271 |      *
272 |      * @param sim Reference to the simulation.
273 |      */
274 |     explicit data(simulation<Time> &sim) : sim_{sim} {}
275 | 
276 |     /// Destructor.
277 |     virtual ~data() = default;
278 | 
279 |     /// State of the event.
280 |     state state_ = state::pending;
281 | 
282 |     /// Promises awaiting the event.
283 |     std::vector<internal::generic_promise_type<Time> *> promises_ = {};
284 | 
285 |     /// Callbacks added to the event.
286 |     std::vector<std::function<void()>> cbs_ = {};
287 | 
288 |     /// Reference to the simulation.
289 |     simulation<Time> &sim_;
290 |   };
291 | 
292 |   /**
293 |    * Constructor.
294 |    *
295 |    * @param data Shared data.
296 |    */
297 |   explicit event(const std::shared_ptr<data> &data_) : data_{data_} {
298 |     assert(data_);
299 |   }
300 | 
301 |   /// Shared data of the event.
302 |   std::shared_ptr<data> data_;
303 | 
304 |   friend class simulation<Time>;
305 |   friend struct std::hash<event<Time>>;
306 | };
307 | 
308 | } // namespace simcpp20
309 | 
310 | namespace std {
311 | 
312 | /// Specialization of std::hash for simcpp20::event.
313 | template <typename Time> struct hash<simcpp20::event<Time>> {
314 |   /**
315 |    * @param ev Event.
316 |    * @return Hash of the event.
317 |    */
318 |   std::size_t operator()(const simcpp20::event<Time> &ev) const {
319 |     return std::hash<decltype(ev.data_.get())>()(ev.data_.get());
320 |   }
321 | };
322 | 
323 | } // namespace std
324 | 


--------------------------------------------------------------------------------
/include/fschuetz04/simcpp20/simulation.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cassert>    // assert
  4 | #include <coroutine>  // std::coroutine_handle
  5 | #include <cstddef>    // std::size_t
  6 | #include <cstdint>    // std::uint64_t
  7 | #include <functional> // std::greater
  8 | #include <memory>     // std::make_shared, std::make_unique
  9 | #include <queue>      // std::priority_queue
 10 | #include <set>        // std::set
 11 | #include <utility>    // std::forward
 12 | #include <vector>     // std::vector
 13 | 
 14 | #include "event.hpp"
 15 | #include "process.hpp"
 16 | #include "promise_type.hpp"
 17 | #include "value_event.hpp"
 18 | 
 19 | namespace simcpp20 {
 20 | 
 21 | using id_type = std::uint64_t;
 22 | 
 23 | /**
 24 |  * Used to run a discrete-event simulation.
 25 |  *
 26 |  * To create a new instance, default-initialize the class:
 27 |  *
 28 |  *     simcpp20::simulation<> sim;
 29 |  *
 30 |  * @tparam Time Type used for simulation time.
 31 |  */
 32 | template <typename Time = double> class simulation {
 33 | private:
 34 |   using event_type = simcpp20::event<Time>;
 35 | 
 36 | public:
 37 |   /// Destructor.
 38 |   ~simulation() {
 39 |     std::set<std::coroutine_handle<>> temp_handles;
 40 |     handles_.swap(temp_handles);
 41 |     for (auto &handle : temp_handles) {
 42 |       handle.destroy();
 43 |     }
 44 |   }
 45 | 
 46 |   /// @return New pending event.
 47 |   event_type event() { return event_type{*this}; }
 48 | 
 49 |   /**
 50 |    * @tparam Value Value type of the event.
 51 |    * @return New pending value event.
 52 |    */
 53 |   template <typename Value> value_event<Value, Time> event() {
 54 |     return value_event<Value, Time>{*this};
 55 |   }
 56 | 
 57 |   /**
 58 |    * @param delay Delay after which to process the event.
 59 |    * @return New pending event.
 60 |    */
 61 |   event_type timeout(Time delay) {
 62 |     auto ev = event();
 63 |     schedule(ev, delay);
 64 |     return ev;
 65 |   }
 66 | 
 67 |   /**
 68 |    * @tparam Value Value type of the event.
 69 |    * @param delay Delay after which to process the event.
 70 |    * @param value Value of the event.
 71 |    * @return New pending value event.
 72 |    */
 73 |   template <typename Value, typename... Args>
 74 |   value_event<Value, Time> timeout(Time delay, Args &&...args) {
 75 |     auto ev = event<Value>();
 76 |     ev.set_value(std::forward<Args>(args)...);
 77 |     schedule(ev, delay);
 78 |     return ev;
 79 |   }
 80 | 
 81 |   /**
 82 |    * @param evs List of awaitables.
 83 |    * @return New pending event which is triggered when any of the given
 84 |    * awaitables is processed.
 85 |    */
 86 |   template <typename... Args> event_type any_of(Args &&...evs) {
 87 |     return any_of_internal(event(), std::forward<Args>(evs)...);
 88 |   }
 89 | 
 90 |   /**
 91 |    * @tparam Value Value type of the event.
 92 |    * @param evs List of awaitables.
 93 |    * @return New pending value event which is triggered when any of the given
 94 |    * awaitables is processed.
 95 |    */
 96 |   template <typename Value, typename... Args>
 97 |   value_event<Value, Time> any_of(Args &&...evs) {
 98 |     return any_of_internal(event<Value>(), std::forward<Args>(evs)...);
 99 |   }
100 | 
101 |   /**
102 |    * @param evs List of awaitables.
103 |    * @return New pending event which is triggered when all of the given
104 |    * awaitables are processed.
105 |    */
106 |   template <typename... Args> event_type all_of(Args &&...evs) {
107 |     auto n_ptr = std::make_shared<std::size_t>(0);
108 |     return all_of_internal(event(), n_ptr, std::forward<Args>(evs)...);
109 |   }
110 | 
111 |   /**
112 |    * @param ev Event to be processed.
113 |    * @param delay Delay after which to process the event.
114 |    */
115 |   void schedule(const event_type &ev, Time delay = Time{0}) {
116 |     assert(delay >= Time{0});
117 | 
118 |     scheduled_evs_.emplace(now() + delay, next_id_, ev);
119 |     ++next_id_;
120 |   }
121 | 
122 |   /// Process the next scheduled event.
123 |   void step() {
124 |     auto sev = scheduled_evs_.top();
125 |     scheduled_evs_.pop();
126 |     now_ = sev.time_;
127 |     sev.ev_.process();
128 |   }
129 | 
130 |   /// Run the simulation until no more events are scheduled.
131 |   void run() {
132 |     while (!empty()) {
133 |       step();
134 |     }
135 |   }
136 | 
137 |   /**
138 |    * Run the simulation until the target time is reached or no more events are
139 |    * scheduled. The target time is reached when the next scheduled event is
140 |    * scheduled at or after the target time.
141 |    *
142 |    * @param target Target time.
143 |    */
144 |   void run_until(Time target) {
145 |     assert(target >= now());
146 | 
147 |     while (!empty() && scheduled_evs_.top().time_ < target) {
148 |       step();
149 |     }
150 | 
151 |     now_ = target;
152 |   }
153 | 
154 |   /// @return Whether no events are scheduled.
155 |   bool empty() const { return scheduled_evs_.empty(); }
156 | 
157 |   /// @return Current simulation time.
158 |   Time now() const { return now_; }
159 | 
160 | private:
161 |   /**
162 |    * Consumes one awaitable for `any_of` and forwards the remaining awaitables.
163 |    *
164 |    * @tparam Event Type of the event to return.
165 |    * @tparam Current Type of the current awaitable.
166 |    * @tparam Args Type of the remaining awaitables.
167 |    * @param any_of_ev Event to trigger when any one of the awaitables is
168 |    * processed.
169 |    * @param current_ev Awaitable to consume.
170 |    * @param next_evs Remaining awaitables to forward.
171 |    * @return Event that is triggered when any one of the awaitables is
172 |    * processed.
173 |    */
174 |   template <typename Event, typename Current, typename... Args>
175 |   Event any_of_internal(Event any_of_ev, Current current_ev,
176 |                         Args &&...next_evs) {
177 |     any_of_internal(any_of_ev, current_ev);
178 |     return any_of_internal(any_of_ev, std::forward<Args>(next_evs)...);
179 |   }
180 | 
181 |   /**
182 |    * Consumes the final awaitable for `any_of`.
183 |    *
184 |    * @param any_of_ev Event to trigger when any one of the awaitables is
185 |    * processed.
186 |    * @param current_ev Awaitable to consume.
187 |    * @return Event that is triggered when any one of the awaitables is
188 |    * processed.
189 |    */
190 |   template <typename Awaitable>
191 |   event_type any_of_internal(event_type any_of_ev,
192 |                              const Awaitable &current_ev) {
193 |     if (current_ev.processed()) {
194 |       any_of_ev.trigger();
195 |     } else {
196 |       current_ev.add_callback([any_of_ev]() { any_of_ev.trigger(); });
197 |     }
198 | 
199 |     return any_of_ev;
200 |   }
201 | 
202 |   /**
203 |    * Consumes the final awaitable for `any_of` with `value_event`.
204 |    *
205 |    * @tparam Value Value type of `value_event`.
206 |    * @param any_of_ev Event to trigger when any one of the events is processed.
207 |    * @param current_ev Event to consume.
208 |    * @return Event that is triggered when any one of the events is processed.
209 |    */
210 |   template <typename Value>
211 |   value_event<Value, Time>
212 |   any_of_internal(value_event<Value, Time> any_of_ev,
213 |                   value_event<Value, Time> current_ev) {
214 |     if (current_ev.processed()) {
215 |       any_of_ev.trigger(current_ev.value());
216 |     } else {
217 |       current_ev.add_callback(
218 |           [any_of_ev, current_ev]() { any_of_ev.trigger(current_ev.value()); });
219 |     }
220 | 
221 |     return any_of_ev;
222 |   }
223 | 
224 |   /**
225 |    * Consumes one awaitable for `all_of` and forwards the remaining awaitables.
226 |    *
227 |    * @tparam Args Type of the remaining awaitables.
228 |    * @param all_of_ev Event to trigger when all of the awaitables are processed.
229 |    * @param n_ptr Number of awaitables not yet processed.
230 |    * @param current_ev Awaitable to consume.
231 |    * @param next_evs Remaining awaitables to forward.
232 |    * @return Event that is triggered when all of the awaitables are processed.
233 |    */
234 |   template <typename Awaitable, typename... Args>
235 |   event_type all_of_internal(event_type all_of_ev,
236 |                              std::shared_ptr<size_t> n_ptr,
237 |                              Awaitable current_ev, Args &&...next_evs) {
238 |     all_of_internal(all_of_ev, n_ptr, current_ev);
239 |     return all_of_internal(all_of_ev, n_ptr, std::forward<Args>(next_evs)...);
240 |   }
241 | 
242 |   /**
243 |    * Consumes the final awaitable for `all_of`.
244 |    *
245 |    * @param all_of_ev Event to trigger when all of the awaitables are processed.
246 |    * @param n_ptr Number of awaitables not yet processed.
247 |    * @param current_ev Awaitable to consume.
248 |    * @return Event that is triggered when all of the awaitables are processed.
249 |    */
250 |   template <typename Awaitable>
251 |   event_type all_of_internal(event_type all_of_ev,
252 |                              std::shared_ptr<size_t> n_ptr,
253 |                              Awaitable current_ev) {
254 |     if (!current_ev.processed()) {
255 |       ++*n_ptr;
256 | 
257 |       current_ev.add_callback([all_of_ev, n_ptr]() {
258 |         if (--*n_ptr == 0) {
259 |           all_of_ev.trigger();
260 |         }
261 |       });
262 |     }
263 | 
264 |     return all_of_ev;
265 |   }
266 | 
267 |   /// One event scheduled to be processed.
268 |   class scheduled_event {
269 |   public:
270 |     /**
271 |      * Constructor.
272 |      *
273 |      * @param time Time at which to process the event.
274 |      * @param id_ Incremental ID to sort events scheduled at the same time by
275 |      * insertion order.
276 |      * @param ev Event to process.
277 |      */
278 |     explicit scheduled_event(Time time, id_type id, const event_type &ev)
279 |         : time_{time}, id_{id}, ev_{ev} {}
280 | 
281 |     /**
282 |      * @param other Scheduled event to compare to.
283 |      * @return Whether this event is scheduled before the given event.
284 |      */
285 |     bool operator>(const scheduled_event &other) const {
286 |       if (time_ != other.time_) {
287 |         return time_ > other.time_;
288 |       }
289 | 
290 |       return id_ > other.id_;
291 |     }
292 | 
293 |     /// Time at which to process the event.
294 |     Time time_;
295 | 
296 |     /**
297 |      * Incremental ID to sort events scheduled at the same time by insertion
298 |      * order.
299 |      */
300 |     id_type id_;
301 | 
302 |     /// Event to process.
303 |     event_type ev_;
304 |   };
305 | 
306 |   /// Scheduled events.
307 |   std::priority_queue<scheduled_event, std::vector<scheduled_event>,
308 |                       std::greater<scheduled_event>>
309 |       scheduled_evs_;
310 | 
311 |   /// Current simulation time.
312 |   Time now_ = Time{0};
313 | 
314 |   /// Next ID for scheduling an event.
315 |   id_type next_id_ = 0;
316 | 
317 |   /// Set of coroutine handles belonging to pending processes.
318 |   std::set<std::coroutine_handle<>> handles_;
319 | 
320 |   friend class internal::generic_promise_type<Time>;
321 | };
322 | 
323 | } // namespace simcpp20
324 | 


--------------------------------------------------------------------------------