BLI_task_size_hints.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <optional>
 
#include "BLI_index_range.hh"
#include "BLI_span.hh"
#include "BLI_utildefines.h"
 
namespace blender::threading {
 
class TaskSizeHints {
 public:
  enum class Type {
    Static,
    IndividualLookup,
    AccumulatedLookup,
  };
 
  Type type;
 
 protected:
  TaskSizeHints(const Type type) : type(type) {}
};
 
namespace detail {
 
class TaskSizeHints_Static : public TaskSizeHints {
 public:
  int64_t size;
 
  TaskSizeHints_Static(const int64_t size) : TaskSizeHints(Type::Static), size(size) {}
};
 
class TaskSizeHints_IndividualLookup : public TaskSizeHints {
 public:
  std::optional<int64_t> full_size;
 
  TaskSizeHints_IndividualLookup(std::optional<int64_t> full_size)
      : TaskSizeHints(Type::IndividualLookup), full_size(full_size)
  {
  }
 
  virtual void lookup_individual_sizes(IndexRange /*range*/,
                                       MutableSpan<int64_t> r_sizes) const = 0;
};
 
class TaskSizeHints_AccumulatedLookup : public TaskSizeHints {
 public:
  TaskSizeHints_AccumulatedLookup() : TaskSizeHints(Type::AccumulatedLookup) {}
 
  virtual int64_t lookup_accumulated_size(IndexRange range) const = 0;
};
 
template<typename Fn>
class TaskSizeHints_IndividualLookupFn : public TaskSizeHints_IndividualLookup {
 private:
  Fn fn_;
 
 public:
  TaskSizeHints_IndividualLookupFn(Fn fn, const std::optional<int64_t> full_size)
      : TaskSizeHints_IndividualLookup(full_size), fn_(std::move(fn))
  {
  }
 
  void lookup_individual_sizes(const IndexRange range, MutableSpan<int64_t> r_sizes) const override
  {
    fn_(range, r_sizes);
  }
};
 
template<typename Fn>
class TaskSizeHints_AccumulatedLookupFn : public TaskSizeHints_AccumulatedLookup {
 private:
  Fn fn_;
 
 public:
  TaskSizeHints_AccumulatedLookupFn(Fn fn) : TaskSizeHints_AccumulatedLookup(), fn_(std::move(fn))
  {
  }
 
  int64_t lookup_accumulated_size(const IndexRange range) const override
  {
    return fn_(range);
  }
};
 
}  // namespace detail
 
inline bool use_single_thread(const TaskSizeHints &size_hints,
                              const IndexRange range,
                              const int64_t threshold)
{
#ifdef __GNUC__ /* False positive warning with GCC. */
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Warray-bounds"
#endif
  switch (size_hints.type) {
    case TaskSizeHints::Type::Static: {
      const int64_t size = static_cast<const detail::TaskSizeHints_Static &>(size_hints).size;
      return size * range.size() <= threshold;
    }
    case TaskSizeHints::Type::IndividualLookup: {
      const std::optional<int64_t> &full_size =
          static_cast<const detail::TaskSizeHints_IndividualLookup &>(size_hints).full_size;
      if (full_size.has_value()) {
        if (*full_size <= threshold) {
          return true;
        }
      }
      return false;
    }
    case TaskSizeHints::Type::AccumulatedLookup: {
      const int64_t accumulated_size =
          static_cast<const detail::TaskSizeHints_AccumulatedLookup &>(size_hints)
              .lookup_accumulated_size(range);
      return accumulated_size <= threshold;
    }
  }
#ifdef __GNUC__
#  pragma GCC diagnostic pop
#endif
  BLI_assert_unreachable();
  return true;
}
 
template<typename Fn>
inline auto individual_task_sizes(Fn &&fn, const std::optional<int64_t> full_size = std::nullopt)
{
  auto array_fn = [fn = std::forward<Fn>(fn)](const IndexRange range,
                                              MutableSpan<int64_t> r_sizes) {
    for (const int64_t i : range.index_range()) {
      r_sizes[i] = fn(range[i]);
    }
  };
  return detail::TaskSizeHints_IndividualLookupFn<decltype(array_fn)>(std::move(array_fn),
                                                                      full_size);
}
 
template<typename Fn> inline auto accumulated_task_sizes(Fn &&fn)
{
  return detail::TaskSizeHints_AccumulatedLookupFn<decltype(fn)>(std::forward<Fn>(fn));
}
 
}  // namespace blender::threading