BLI_compute_context.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_array.hh"
#include "BLI_linear_allocator.hh"
#include "BLI_stack.hh"
#include "BLI_string_ref.hh"
#include "BLI_struct_equality_utils.hh"
 
namespace blender {
 
struct ComputeContextHash {
  uint64_t v1 = 0;
  uint64_t v2 = 0;
 
  uint64_t hash() const
  {
    return v1;
  }
 
  BLI_STRUCT_EQUALITY_OPERATORS_2(ComputeContextHash, v1, v2)
 
  void mix_in(const void *data, int64_t len);
 
  friend std::ostream &operator<<(std::ostream &stream, const ComputeContextHash &hash);
};
 
class ComputeContext {
 private:
  const char *static_type_;
  const ComputeContext *parent_ = nullptr;
 
 protected:
  ComputeContextHash hash_;
 
 public:
  ComputeContext(const char *static_type, const ComputeContext *parent)
      : static_type_(static_type), parent_(parent)
  {
    if (parent != nullptr) {
      hash_ = parent_->hash_;
    }
  }
  virtual ~ComputeContext() = default;
 
  const ComputeContextHash &hash() const
  {
    return hash_;
  }
 
  const char *static_type() const
  {
    return static_type_;
  }
 
  const ComputeContext *parent() const
  {
    return parent_;
  }
 
  void print_stack(std::ostream &stream, StringRef name) const;
 
  virtual void print_current_in_line(std::ostream &stream) const = 0;
 
  friend std::ostream &operator<<(std::ostream &stream, const ComputeContext &compute_context);
};
 
class ComputeContextBuilder {
 private:
  LinearAllocator<> allocator_;
  Stack<destruct_ptr<ComputeContext>> contexts_;
  std::optional<Vector<destruct_ptr<ComputeContext>>> old_contexts_;
 
 public:
  void keep_old_contexts()
  {
    if (!old_contexts_.has_value()) {
      old_contexts_.emplace();
    }
  }
 
  bool is_empty() const
  {
    return contexts_.is_empty();
  }
 
  const ComputeContext *current() const
  {
    if (contexts_.is_empty()) {
      return nullptr;
    }
    return contexts_.peek().get();
  }
 
  const ComputeContextHash hash() const
  {
    BLI_assert(!contexts_.is_empty());
    return this->current()->hash();
  }
 
  template<typename T, typename... Args> void push(Args &&...args)
  {
    const ComputeContext *current = this->current();
    destruct_ptr<T> context = allocator_.construct<T>(current, std::forward<Args>(args)...);
    contexts_.push(std::move(context));
  }
 
  void pop()
  {
    auto context = contexts_.pop();
    if (old_contexts_) {
      old_contexts_->append(std::move(context));
    }
  }
 
  void pop_until(const ComputeContext *context)
  {
    while (!contexts_.is_empty()) {
      if (contexts_.peek().get() == context) {
        return;
      }
      this->pop();
    }
    /* Should have found the context above if it's not null. */
    BLI_assert(context == nullptr);
  }
};
 
}  // namespace blender