mlTaskSystem.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2022, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "mlUtilsSystem.h"
 
#include <stlab/concurrency/task.hpp>
#include <stlab/concurrency/future.hpp>
#include <stlab/concurrency/immediate_executor.hpp>
#include <stlab/concurrency/await.hpp>
 
ML_START_NAMESPACE
 
void ML_UTILS_EXPORT execute_low(stlab::task<void()> f);
void ML_UTILS_EXPORT execute_default(stlab::task<void()> f);
void ML_UTILS_EXPORT execute_high(stlab::task<void()> f);
 
namespace detail
{
  template <void (*Execute)(stlab::task<void()>)>
  struct executor
  {
    void operator()(stlab::task<void()> f) const
    {
      Execute(std::move(f));
    }
  };
 
#if STLAB_TASK_SYSTEM(PORTABLE)
  ML_UTILS_EXPORT stlab::detail::priority_task_system& pts();
#endif
}
 
/*
 * These type definitions provide an interface to the stlab's
 * TaskSystem. Use only instances of these types to access
 * it.
 *
 * Never use the stlab::default_executor directly because
 * that would instantiate in each shared library and in main
 * a separate instance of the TaskSystem. This is against the
 * principles that there should only be one task system per
 * application and destruction of the TaskSystem while closing
 * the applications does not work as intended.
 */
using low_executor = detail::executor<execute_low>;
using default_executor = detail::executor<execute_default>;
using high_executor = detail::executor<execute_high>;
 
/*
 * This function must be called just before the end of
 * int main(). It ensures that all remaining tasks which
 * are still in the queue of the TaskSystem will not executed
 * any more and that the TaskSystem is shutdown in a controlled
 * manner.
 */
void ML_UTILS_EXPORT pre_exit();
 
 
namespace taskSystem
{
  /*
   * This is a copy of stlab::await, which ensures that always the same instance of the
   * priority_task_system singleton is returned (via detail::pts()), regardless of the compilation unit.
   * See https://github.com/stlab/libraries/issues/519
   */
  template <typename T>
  T await(stlab::future<T> x) {
    if (auto result = x.get_try())
      return stlab::detail::_get_optional<decltype(result)>{}(std::move(result)); // if ready, done
 
    std::mutex m;
    std::condition_variable condition;
    bool flag{false};
 
    auto hold = std::move(x).recover(stlab::immediate_executor, [&](auto&& r) {
                                       x = std::forward<decltype(r)>(r);
                                       {
                                         std::unique_lock<std::mutex> lock{m};
                                         flag = true;
                                         condition.notify_one(); // must notify under lock
                                       }
                                     });
 
  #if STLAB_TASK_SYSTEM(PORTABLE)
    if (!detail::pts().wake()) detail::pts().add_thread();
 
    /*
        If no tasks are available we wait for one tick of the system clock and exponentially
        back off on the wait as long as no tasks are available.
    */
 
    for (auto backoff{std::chrono::steady_clock::duration{std::chrono::milliseconds{1}}}; true;
         backoff *= 2) {
      {
        std::unique_lock<std::mutex> lock{m};
        if (condition.wait_for(lock, backoff, [&] { return flag; })) {
          break;
        }
      }
      detail::pts().wake(); // try to wake something to unstick.
    }
 
  #else
 
    {
      std::unique_lock<std::mutex> lock{m};
      condition.wait(lock, [&] { return flag; });
    }
 
  #endif
 
    return stlab::detail::_get_ready_future<T>{}(std::move(x));
  }
}
 
ML_END_NAMESPACE