b2threading.H

//------------------------------------------------------------------------
// b2threading.H --
//
//
// written by Johannes Wendler <johannes.wendler@dlr.de>
//            Thomas Blome <thomas.blome@dlr.de>
//
// Copyright (c) 2024 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//                    Linder Höhe, 51147 Köln
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef B2THREADING_H_
#define B2THREADING_H_
 
#include <functional>
 
#ifdef HAVE_LIB_TBB
#include "tbb/spin_rw_mutex.h"
#include "tbb/tbb.h"
#if TBB_VERSION_MAJOR >= 2021
#include "oneapi/tbb/mutex.h"
#else
#include "tbb/mutex.h"
#endif
#endif
 
namespace b2000 {
 
#ifdef HAVE_LIB_TBB
template <typename Loop, typename... Args>
struct TbbTaskWrapper {
    TbbTaskWrapper(Args&&... args) : loop(Loop(std::forward<Args>(args)...)) {}
 
    void operator()(const tbb::blocked_range<size_t>& r) const { loop(r.begin(), r.end()); }
 
private:
    Loop loop;
};
#endif
 
template <typename Loop, typename... Args>
void b2RunPossiblyParallel(size_t begin, size_t end, Args&&... args) {
#ifdef HAVE_LIB_TBB
    tbb::parallel_for(
          tbb::blocked_range<size_t>(begin, end),
          TbbTaskWrapper<Loop, Args...>(std::forward<Args>(args)...), tbb::auto_partitioner());
#else
    auto loop = Loop(std::forward<Args>(args)...);
    loop(begin, end);
#endif
}
 
#ifdef HAVE_LIB_TBB
struct b2Mutex : public tbb::mutex {};
 
struct b2spin_rw_mutex : public tbb::spin_rw_mutex {};
#else
struct b2Mutex {
    struct scoped_lock {
        explicit scoped_lock(b2Mutex mutex) {}
    };
};
 
struct b2spin_rw_mutex {
    struct scoped_lock {
        scoped_lock() {}
        explicit scoped_lock(b2spin_rw_mutex mutex) {}
        void acquire(b2spin_rw_mutex mutex) {}
        void release() {}
    };
};
#endif
 
#ifdef HAVE_LIB_TBB
 
template <typename Loop, typename Args>
struct RecursiveTask {
    RecursiveTask(
          size_t tree_node_, size_t sublevel_, tbb::task_group& tk_group_, Args& args_,
          b2Mutex& mutex_)
        : tree_node(tree_node_),
          sublevel(sublevel_),
          tk_group(tk_group_),
          args(args_),
          mutex(mutex_) {}
    size_t tree_node;
    size_t sublevel;
    tbb::task_group& tk_group;
    Args& args;
    b2Mutex& mutex;
 
    void operator()() const {
        if (sublevel > 0) {
            tk_group.run(RecursiveTask(2 * tree_node + 1, sublevel - 1, tk_group, args, mutex));
            tk_group.run(RecursiveTask(2 * tree_node + 2, sublevel - 1, tk_group, args, mutex));
            tk_group.wait();
        }
        if (args.tree[tree_node].first < args.tree[tree_node].second) {
            tbb::parallel_for(
                  tbb::blocked_range<size_t>(
                        args.tree[tree_node].first, args.tree[tree_node].second),
                  TbbTaskWrapper<Loop, Args&, b2Mutex&>(args, mutex), tbb::auto_partitioner());
        }
    }
};
 
#endif
 
template <typename Loop, typename Args>
void b2runRecursively(size_t tree_node, size_t sublevel, Args& args, b2Mutex& mutex) {
#ifdef HAVE_LIB_TBB
    tbb::task_group tk_group;
    tk_group.run(RecursiveTask<Loop, Args>(tree_node, sublevel, tk_group, args, mutex));
    tk_group.wait();
#else
    auto loop = Loop(args, mutex);
    loop(args.tree[0].first, args.tree[0].second);
#endif
}
 
}  // namespace b2000
#endif