github/verilator
1
0
Fork 1
mirror of https://github.com/verilator/verilator.git synced 2025-02-08 14:41:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
78fe77db0f
verilator/test_regress/t/t_timing_debug1.out

1992 lines
114 KiB
Plaintext
Raw Normal View History

Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
-V{t#,#}+ Vt_timing_debug1___024root___ctor_var_reset
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
-V{t#,#}+ Initial
-V{t#,#}+ Vt_timing_debug1___024root___eval_static
-V{t#,#}+ Vt_timing_debug1___024root___eval_static__TOP
-V{t#,#}+ Vt_timing_debug1___024root___eval_initial
-V{t#,#}+ Vt_timing_debug1___024root___eval_initial__TOP__0
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_initial__TOP__1
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_initial__TOP__2
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_initial__TOP__3
-V{t#,#}+ Vt_timing_debug1___024root___eval_settle
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__stl
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__stl
-V{t#,#} 'stl' region trigger index 0 is active: Internal 'stl' trigger - first iteration
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'stl' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk1__0)
-V{t#,#} 'stl' region trigger index 2 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#} 'stl' region trigger index 3 is active: @([hybrid] t.c1)
-V{t#,#}+ Vt_timing_debug1___024root___eval_stl
-V{t#,#}+ Vt_timing_debug1___024root___stl_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___stl_sequent__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___stl_sequent__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___stl_comb__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___stl_comb__TOP__2
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__stl
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__stl
-V{t#,#} No triggers active
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#} 'act' region trigger index 2 is active: @([hybrid] t.c1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 3: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 3: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:18
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 6: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 7: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 7: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 9: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 9: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 11: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 12: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 13: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 5 is active: @(posedge t.clk2)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Resuming processes waiting for @(posedge t.clk2)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 2 is active: @([hybrid] t.c1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 12: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 12: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 13: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 13: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 15: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 15: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:18
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 18: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 19: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 19: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 21: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 21: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 22: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 25: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 24: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 24: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 25: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 25: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 27: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 27: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 30: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 31: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 31: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 33: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#} 'act' region trigger index 5 is active: @(posedge t.clk2)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Resuming processes waiting for @(posedge t.clk2)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 2 is active: @([hybrid] t.c1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 34: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 36: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Awaiting time 37: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 36: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 37: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 37: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 39: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 39: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:18
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 42: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 43: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 43: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 45: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 44: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 45: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 45: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 48: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 49: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 49: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 51: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 51: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 54: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 55: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 57: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 5 is active: @(posedge t.clk2)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Resuming processes waiting for @(posedge t.clk2)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 2 is active: @([hybrid] t.c1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 56: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 57: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 57: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 60: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 61: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 61: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 63: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 63: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 67: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 66: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 67: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 77: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 69: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 69: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 77: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 72: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 73: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 77: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 73: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 75: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 77: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 75: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 77: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 3 is active: @(posedge t.clk1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming processes waiting for @(posedge t.clk1)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___nba_sequent__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 77: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 79: Process waiting at t/t_timing_sched.v:17
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:17
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 1 is active: @([hybrid] __VassignWtmp_t.clk2__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__1
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 5 is active: @(posedge t.clk2)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#} Ready processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#} Resuming processes waiting for @(posedge t.clk2)
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:18
-V{t#,#} Suspending process waiting for @(posedge t.clk1) at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__1
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 2 is active: @([hybrid] t.c1)
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk1):
-V{t#,#} - Process waiting at t/t_timing_sched.v:18
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__2
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+++++TOP Evaluate Vt_timing_debug1::eval_step
-V{t#,#}+ Vt_timing_debug1___024root___eval_debug_assertions
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}MTask0 starting
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Eval
-V{t#,#}+ Vt_timing_debug1___024root___eval
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} 'act' region trigger index 4 is active: @([true] __VdlySched.awaitingCurrentTime())
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#} Delayed processes:
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:48
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 79: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Awaiting time 88: Process waiting at t/t_timing_sched.v:13
-V{t#,#} Awaiting time 78: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming delayed processes
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:46
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:13
*-* All Finished *-*
-V{t#,#} Resuming: Process waiting at t/t_timing_sched.v:10
-V{t#,#} Suspending process waiting for @(posedge t.clk2) at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#} 'act' region trigger index 0 is active: @([hybrid] __VassignWtmp_t.clk1__0)
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#} Committing processes waiting for @(posedge t.clk2):
-V{t#,#} - Process waiting at t/t_timing_sched.v:46
-V{t#,#}+ Vt_timing_debug1___024root___timing_resume
-V{t#,#}+ Vt_timing_debug1___024root___eval_act
-V{t#,#}+ Vt_timing_debug1___024root___act_sequent__TOP__0
Internals: Add `V3UniqueNames` consistency assertion (#3692)
2022-10-21 11:05:38 +00:00
-V{t#,#}+ Vt_timing_debug1___024root____Vfork_h########__0__0
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
-V{t#,#}+ Vt_timing_debug1___024root___eval_nba
-V{t#,#}+ Vt_timing_debug1___024root___act_comb__TOP__0
-V{t#,#}+ Vt_timing_debug1___024root___eval_triggers__act
-V{t#,#}+ Vt_timing_debug1___024root___dump_triggers__act
-V{t#,#} No triggers active
-V{t#,#}+ Vt_timing_debug1___024root___timing_commit
Remove --no-threads; require --threads 1 for single threaded (#3703).
2022-11-05 12:47:34 +00:00
-V{t#,#}End-of-eval cleanup
Timing support (#3363) Adds timing support to Verilator. It makes it possible to use delays, event controls within processes (not just at the start), wait statements, and forks. Building a design with those constructs requires a compiler that supports C++20 coroutines (GCC 10, Clang 5). The basic idea is to have processes and tasks with delays/event controls implemented as C++20 coroutines. This allows us to suspend and resume them at any time. There are five main runtime classes responsible for managing suspended coroutines: * `VlCoroutineHandle`, a wrapper over C++20's `std::coroutine_handle` with move semantics and automatic cleanup. * `VlDelayScheduler`, for coroutines suspended by delays. It resumes them at a proper simulation time. * `VlTriggerScheduler`, for coroutines suspended by event controls. It resumes them if its corresponding trigger was set. * `VlForkSync`, used for syncing `fork..join` and `fork..join_any` blocks. * `VlCoroutine`, the return type of all verilated coroutines. It allows for suspending a stack of coroutines (normally, C++ coroutines are stackless). There is a new visitor in `V3Timing.cpp` which: * scales delays according to the timescale, * simplifies intra-assignment timing controls and net delays into regular timing controls and assignments, * simplifies wait statements into loops with event controls, * marks processes and tasks with timing controls in them as suspendable, * creates delay, trigger scheduler, and fork sync variables, * transforms timing controls and fork joins into C++ awaits There are new functions in `V3SchedTiming.cpp` (used by `V3Sched.cpp`) that integrate static scheduling with timing. This involves providing external domains for variables, so that the necessary combinational logic gets triggered after coroutine resumption, as well as statements that need to be injected into the design eval function to perform this resumption at the correct time. There is also a function that transforms forked processes into separate functions. See the comments in `verilated_timing.h`, `verilated_timing.cpp`, `V3Timing.cpp`, and `V3SchedTiming.cpp`, as well as the internals documentation for more details. Signed-off-by: Krzysztof Bieganski <kbieganski@antmicro.com>
2022-08-22 12:26:32 +00:00
-V{t#,#}+ Vt_timing_debug1___024root___eval_final
Reference in New Issue Copy Permalink