Skip to content

las3_pub / predictable_parallel_patterns

Go to a project
Commit 08283a37 by FritzFlorian
Options

Add scheduler_active flag and PLS_SERIAL_ELUSION compile option. 

The flag can be used to run code annotated with PLS outside of a scheduler environment,
i.e. the app does not crash if the code is called without context. The compile option
allows to omit all spawn and sync calls during compilation, creating the equivalent serial code.
parent f9ec6ecf
Pipeline #1497 passed with stages
in 3 minutes 57 seconds
Expand all
Inline Side-by-side
Showing with 87 additions and 45 deletions
README.md
...@@ -141,8 +141,21 @@ Testing is done using [Catch2](https://github.com/catchorg/Catch2/) ...@@ -141,8 +141,21 @@ Testing is done using [Catch2](https://github.com/catchorg/Catch2/)
in the test subfolder. Tests are build into a target called `tests` in the test subfolder. Tests are build into a target called `tests`
and can be executed simply by building this executabe and running it. and can be executed simply by building this executabe and running it.
### PLS profiler
The PLS profiler records the DAG for each scheduler invocation.
Stats can be queried form it and it can be printed in .dot format,
which can later be rendered by the dot software to inspect the actual
executed graph.
The most useful tools are to analyze the maximum memory required per
coroutine stack, th computational depth, T_1 and T_inf.
### Data Race Detection ### Data Race Detection
WARNING: the latest build of clang/thread sanitizer is required for this to work,
as a recent bug-fix regarding user level thread is required!
As this project contains a lot concurrent code we use As this project contains a lot concurrent code we use
[Thread Sanitizer](https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual) [Thread Sanitizer](https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual)
in our CI process and optional in other builds. To setup CMake builds in our CI process and optional in other builds. To setup CMake builds
......
app/benchmark_fft/main.cpp
#include "pls/pls.h" #include "pls/pls.h"
using namespace pls;
#include "benchmark_runner.h" #include "benchmark_runner.h"
#include "benchmark_base/fft.h" #include "benchmark_base/fft.h"
...@@ -17,13 +15,13 @@ void pls_conquer(fft::complex_vector::iterator data, fft::complex_vector::iterat ...@@ -17,13 +15,13 @@ void pls_conquer(fft::complex_vector::iterator data, fft::complex_vector::iterat
fft::conquer(data, swap_array, n / 2); fft::conquer(data, swap_array, n / 2);
fft::conquer(data + n / 2, swap_array + n / 2, n / 2); fft::conquer(data + n / 2, swap_array + n / 2, n / 2);
} else { } else {
spawn([data, n, swap_array]() { pls::spawn([data, n, swap_array]() {
pls_conquer(data, swap_array, n / 2); pls_conquer(data, swap_array, n / 2);
}); });
spawn([data, n, swap_array]() { pls::spawn([data, n, swap_array]() {
pls_conquer(data + n / 2, swap_array + n / 2, n / 2); pls_conquer(data + n / 2, swap_array + n / 2, n / 2);
}); });
sync(); pls::sync();
} }
fft::combine(data, n); fft::combine(data, n);
...@@ -45,7 +43,7 @@ int main(int argc, char **argv) { ...@@ -45,7 +43,7 @@ int main(int argc, char **argv) {
fft::complex_vector swap_array(fft::SIZE); fft::complex_vector swap_array(fft::SIZE);
fft::fill_input(data); fft::fill_input(data);
scheduler scheduler{(unsigned) num_threads, MAX_NUM_TASKS, MAX_STACK_SIZE}; pls::scheduler scheduler{(unsigned) num_threads, MAX_NUM_TASKS, MAX_STACK_SIZE};
// scheduler.get_profiler().disable_memory_measure(); // scheduler.get_profiler().disable_memory_measure();
runner.run_iterations(10, [&]() { runner.run_iterations(10, [&]() {
......
app/benchmark_fib/main.cpp
#include "pls/pls.h" #include "pls/pls.h"
using namespace pls;
#include <iostream> #include <iostream>
#include "benchmark_runner.h" #include "benchmark_runner.h"
...@@ -18,13 +16,13 @@ int pls_fib(int n) { ...@@ -18,13 +16,13 @@ int pls_fib(int n) {
} }
int a, b; int a, b;
spawn([n, &a]() { pls::spawn([n, &a]() {
a = pls_fib(n - 1); a = pls_fib(n - 1);
}); });
spawn([n, &b]() { pls::spawn([n, &b]() {
b = pls_fib(n - 2); b = pls_fib(n - 2);
}); });
sync(); pls::sync();
return a + b; return a + b;
} }
...@@ -41,7 +39,7 @@ int main(int argc, char **argv) { ...@@ -41,7 +39,7 @@ int main(int argc, char **argv) {
string full_directory = directory + "/PLS_v3/"; string full_directory = directory + "/PLS_v3/";
benchmark_runner runner{full_directory, test_name}; benchmark_runner runner{full_directory, test_name};
scheduler scheduler{(unsigned) num_threads, MAX_NUM_TASKS, MAX_STACK_SIZE}; pls::scheduler scheduler{(unsigned) num_threads, MAX_NUM_TASKS, MAX_STACK_SIZE};
volatile int res; volatile int res;
// scheduler.get_profiler().disable_memory_measure(); // scheduler.get_profiler().disable_memory_measure();
......
lib/pls/include/pls/internal/scheduling/scheduler.h
...@@ -79,12 +79,24 @@ class scheduler { ...@@ -79,12 +79,24 @@ class scheduler {
* @param lambda the lambda to be executed in parallel. * @param lambda the lambda to be executed in parallel.
*/ */
template<typename Function> template<typename Function>
static void spawn(Function &&lambda); static void spawn(Function &&lambda) {
#ifdef PLS_SERIAL_ELUSION
lambda();
#else
spawn_internal(std::forward<Function>(lambda));
#endif
}
/** /**
* Waits for all potentially parallel child tasks created with spawn(...). * Waits for all potentially parallel child tasks created with spawn(...).
*/ */
static void sync(); static void sync() {
#ifdef PLS_SERIAL_ELUSION
return;
#else
sync_internal();
#endif
}
/** /**
* Explicitly terminate the worker threads. Scheduler must not be used after this. * Explicitly terminate the worker threads. Scheduler must not be used after this.
...@@ -108,6 +120,10 @@ class scheduler { ...@@ -108,6 +120,10 @@ class scheduler {
#endif #endif
private: private:
template<typename Function>
static void spawn_internal(Function &&lambda);
static void sync_internal();
static context_switcher::continuation slow_return(thread_state &calling_state); static context_switcher::continuation slow_return(thread_state &calling_state);
static void work_thread_main_loop(); static void work_thread_main_loop();
......
lib/pls/include/pls/internal/scheduling/thread_state.h
...@@ -44,6 +44,8 @@ struct PLS_CACHE_ALIGN thread_state { ...@@ -44,6 +44,8 @@ struct PLS_CACHE_ALIGN thread_state {
std::minstd_rand random_; std::minstd_rand random_;
base_task *active_task_; base_task *active_task_;
static thread_local bool is_scheduler_active_;
#if PLS_SLEEP_WORKERS_ON_EMPTY #if PLS_SLEEP_WORKERS_ON_EMPTY
PLS_CACHE_ALIGN std::atomic<data_structures::stamped_integer> queue_empty_{EMPTY_QUEUE_STATE::QUEUE_NON_EMPTY}; PLS_CACHE_ALIGN std::atomic<data_structures::stamped_integer> queue_empty_{EMPTY_QUEUE_STATE::QUEUE_NON_EMPTY};
#endif #endif
...@@ -76,6 +78,13 @@ struct PLS_CACHE_ALIGN thread_state { ...@@ -76,6 +78,13 @@ struct PLS_CACHE_ALIGN thread_state {
[[nodiscard]] static thread_state &PLS_NOINLINE get(); [[nodiscard]] static thread_state &PLS_NOINLINE get();
static void set(thread_state *); static void set(thread_state *);
[[nodiscard]] static bool is_scheduler_active() {
return is_scheduler_active_;
}
static void set_scheduler_active(bool active) {
is_scheduler_active_ = active;
}
[[nodiscard]] unsigned get_thread_id() const { return thread_id_; } [[nodiscard]] unsigned get_thread_id() const { return thread_id_; }
[[nodiscard]] task_manager &get_task_manager() { return task_manager_; } [[nodiscard]] task_manager &get_task_manager() { return task_manager_; }
[[nodiscard]] scheduler &get_scheduler() { return scheduler_; } [[nodiscard]] scheduler &get_scheduler() { return scheduler_; }
......
lib/pls/src/internal/scheduling/scheduler.cpp
...@@ -42,6 +42,7 @@ void scheduler::work_thread_main_loop() { ...@@ -42,6 +42,7 @@ void scheduler::work_thread_main_loop() {
void scheduler::work_thread_work_section() { void scheduler::work_thread_work_section() {
thread_state &my_state = thread_state::get(); thread_state &my_state = thread_state::get();
my_state.set_scheduler_active(true);
unsigned const num_threads = my_state.get_scheduler().num_threads(); unsigned const num_threads = my_state.get_scheduler().num_threads();
if (my_state.get_thread_id() == 0) { if (my_state.get_thread_id() == 0) {
...@@ -145,48 +146,54 @@ void scheduler::work_thread_work_section() { ...@@ -145,48 +146,54 @@ void scheduler::work_thread_work_section() {
} }
} }
} }
my_state.set_scheduler_active(false);
} }
void scheduler::sync() { void scheduler::sync_internal() {
thread_state &syncing_state = thread_state::get(); if (thread_state::is_scheduler_active()) {
thread_state &syncing_state = thread_state::get();
base_task *active_task = syncing_state.get_active_task(); base_task *active_task = syncing_state.get_active_task();
base_task *spawned_task = active_task->next_; base_task *spawned_task = active_task->next_;
#if PLS_PROFILING_ENABLED #if PLS_PROFILING_ENABLED
syncing_state.get_scheduler().profiler_.task_finish_stack_measure(syncing_state.get_thread_id(), syncing_state.get_scheduler().profiler_.task_finish_stack_measure(syncing_state.get_thread_id(),
active_task->stack_memory_, active_task->stack_memory_,
active_task->stack_size_, active_task->stack_size_,
active_task->profiling_node_); active_task->profiling_node_);
syncing_state.get_scheduler().profiler_.task_stop_running(syncing_state.get_thread_id(), syncing_state.get_scheduler().profiler_.task_stop_running(syncing_state.get_thread_id(),
active_task->profiling_node_); active_task->profiling_node_);
auto *next_dag_node = auto *next_dag_node =
syncing_state.get_scheduler().profiler_.task_sync(syncing_state.get_thread_id(), active_task->profiling_node_); syncing_state.get_scheduler().profiler_.task_sync(syncing_state.get_thread_id(), active_task->profiling_node_);
active_task->profiling_node_ = next_dag_node; active_task->profiling_node_ = next_dag_node;
#endif #endif
if (active_task->is_synchronized_) { if (active_task->is_synchronized_) {
#if PLS_PROFILING_ENABLED #if PLS_PROFILING_ENABLED
thread_state::get().get_scheduler().profiler_.task_start_running(thread_state::get().get_thread_id(), thread_state::get().get_scheduler().profiler_.task_start_running(thread_state::get().get_thread_id(),
thread_state::get().get_active_task()->profiling_node_); thread_state::get().get_active_task()->profiling_node_);
#endif #endif
return; // We are already the sole owner of last_task return; // We are already the sole owner of last_task
} else { } else {
auto continuation = auto continuation =
spawned_task->run_as_task([active_task, spawned_task, &syncing_state](context_switcher::continuation cont) { spawned_task->run_as_task([active_task, spawned_task, &syncing_state](context_switcher::continuation cont) {
active_task->continuation_ = std::move(cont); active_task->continuation_ = std::move(cont);
syncing_state.set_active_task(spawned_task); syncing_state.set_active_task(spawned_task);
return slow_return(syncing_state); return slow_return(syncing_state);
}); });
PLS_ASSERT(!continuation.valid(), PLS_ASSERT(!continuation.valid(),
"We only return to a sync point, never jump to it directly." "We only return to a sync point, never jump to it directly."
"This must therefore never return an unfinished fiber/continuation."); "This must therefore never return an unfinished fiber/continuation.");
#if PLS_PROFILING_ENABLED #if PLS_PROFILING_ENABLED
thread_state::get().get_scheduler().profiler_.task_start_running(thread_state::get().get_thread_id(), thread_state::get().get_scheduler().profiler_.task_start_running(thread_state::get().get_thread_id(),
thread_state::get().get_active_task()->profiling_node_); thread_state::get().get_active_task()->profiling_node_);
#endif #endif
return; // We cleanly synced to the last one finishing work on last_task return; // We cleanly synced to the last one finishing work on last_task
}
} else {
// Scheduler not active
return;
} }
} }
......
lib/pls/src/internal/scheduling/thread_state.cpp
...@@ -3,6 +3,7 @@ ...@@ -3,6 +3,7 @@
namespace pls::internal::scheduling { namespace pls::internal::scheduling {
thread_local thread_state *my_thread_state{nullptr}; thread_local thread_state *my_thread_state{nullptr};
thread_local bool thread_state::is_scheduler_active_{false};
thread_state &thread_state::get() { return *my_thread_state; } thread_state &thread_state::get() { return *my_thread_state; }
void thread_state::set(thread_state *new_state) { my_thread_state = new_state; } void thread_state::set(thread_state *new_state) { my_thread_state = new_state; }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment