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 "BLI_cache_mutex.hh"
#include "BLI_string_ref.hh"
#include "BLI_struct_equality_utils.hh"
 
namespace blender {
 
class ComputeContext;

struct ComputeContextHash {
  uint64_t v1 = 0;
  uint64_t v2 = 0;
 
  uint64_t hash() const
  {
    return v1;
  }
 
  BLI_STRUCT_EQUALITY_OPERATORS_2(ComputeContextHash, v1, v2)
 
  
  template<size_t N, typename... Args>
  static ComputeContextHash from(const ComputeContext *parent,
                                 const char (&type_str)[N],
                                 Args &&...args);
 
  friend std::ostream &operator<<(std::ostream &stream, const ComputeContextHash &hash);
 
 private:
  template<typename... Args> static ComputeContextHash from_shallow_bytes(Args &&...args);

  static ComputeContextHash from_bytes(const void *data, int64_t len);
};

class ComputeContext {
 protected:
  const ComputeContext *parent_ = nullptr;

  mutable ComputeContextHash hash_;
 
 private:
  mutable CacheMutex hash_mutex_;
 
 public:
  ComputeContext(const ComputeContext *parent) : parent_(parent) {}
  virtual ~ComputeContext() = default;
 
  const ComputeContextHash &hash() const
  {
    hash_mutex_.ensure([&]() { hash_ = this->compute_hash(); });
    return hash_;
  }
 
  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);
 
 private:
  virtual ComputeContextHash compute_hash() const = 0;
};
 
template<size_t N, typename... Args>
inline ComputeContextHash ComputeContextHash::from(const ComputeContext *parent,
                                                   const char (&type_str)[N],
                                                   Args &&...args)
{
  return ComputeContextHash::from_shallow_bytes(
      parent ? parent->hash() : ComputeContextHash{0, 0}, type_str, args...);
}
 
template<typename... Args>
inline ComputeContextHash ComputeContextHash::from_shallow_bytes(Args &&...args)
{
  /* Copy all values into a contiguous buffer. Intentionally don't use std::tuple to avoid any
   * potential padding. */
  constexpr int64_t size_sum = (sizeof(args) + ...);
  char buffer[size_sum];
  int64_t offset = 0;
  (
      [&] {
        using Arg = std::remove_reference_t<std::remove_cv_t<Args>>;
        static_assert(std::has_unique_object_representations_v<Arg>);
        const Arg &arg = args;
        memcpy(buffer + offset, &arg, sizeof(Arg));
        offset += sizeof(Arg);
      }(),
      ...);
  /* Compute the hash of that buffer. */
  return ComputeContextHash::from_bytes(buffer, offset);
}
 
}  // namespace blender