dom/canvas/WebGLCommandQueue.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef WEBGLCOMMANDQUEUE_H_
   7 #define WEBGLCOMMANDQUEUE_H_
   8
   9 #include <type_traits>
  10 #include "mozilla/FunctionTypeTraits.h"
  11 #include "mozilla/gfx/Logging.h"
  12 #include "mozilla/ipc/IPDLParamTraits.h"
  13 #include "QueueParamTraits.h"
  14 #include "WebGLTypes.h"
  15
  16 namespace mozilla {
  17
  18 namespace webgl {
  19
  20 class RangeConsumerView final : public webgl::ConsumerView<RangeConsumerView> {
  21   RangedPtr<const uint8_t> mSrcItr;
  22   const RangedPtr<const uint8_t> mSrcEnd;
  23
  24  public:
  25   auto Remaining() const { return *MaybeAs<size_t>(mSrcEnd - mSrcItr); }
  26
  27   explicit RangeConsumerView(const Range<const uint8_t> range)
  28       : ConsumerView(this), mSrcItr(range.begin()), mSrcEnd(range.end()) {
  29     (void)Remaining();  // assert size non-negative
  30   }
  31
  32   void AlignTo(const size_t alignment) {
  33     const auto padToAlign = AlignmentOffset(alignment, mSrcItr.get());
  34     if (MOZ_UNLIKELY(padToAlign > Remaining())) {
  35       mSrcItr = mSrcEnd;
  36       return;
  37     }
  38     mSrcItr += padToAlign;
  39   }
  40
  41   template <typename T>
  42   Maybe<Range<const T>> ReadRange(const size_t elemCount) {
  43     constexpr auto alignment = alignof(T);
  44     AlignTo(alignment);
  45
  46     constexpr auto elemSize = sizeof(T);
  47     const auto byteSizeChecked = CheckedInt<size_t>(elemCount) * elemSize;
  48     MOZ_RELEASE_ASSERT(byteSizeChecked.isValid());
  49     const auto& byteSize = byteSizeChecked.value();
  50
  51     const auto remaining = Remaining();
  52     if (MOZ_UNLIKELY(byteSize > remaining)) return {};
  53
  54     const auto begin = reinterpret_cast<const T*>(mSrcItr.get());
  55     mSrcItr += byteSize;
  56     return Some(Range<const T>{begin, elemCount});
  57   }
  58 };
  59
  60 // -
  61
  62 namespace details {
  63
  64 class SizeOnlyProducerView final
  65     : public webgl::ProducerView<SizeOnlyProducerView> {
  66   struct Info {
  67     size_t requiredByteCount = 0;
  68     size_t alignmentOverhead = 0;
  69   };
  70   Info mInfo;
  71
  72  public:
  73   SizeOnlyProducerView() : ProducerView(this) {}
  74
  75   template <typename T>
  76   bool WriteFromRange(const Range<const T>& src) {
  77     constexpr auto alignment = alignof(T);
  78     const size_t byteSize = ByteSize(src);
  79     // printf_stderr("SizeOnlyProducerView: @%zu +%zu\n", alignment, byteSize);
  80
  81     const auto padToAlign = AlignmentOffset(alignment, mInfo.requiredByteCount);
  82     mInfo.alignmentOverhead += padToAlign;
  83
  84     mInfo.requiredByteCount += padToAlign;
  85     mInfo.requiredByteCount += byteSize;
  86     return true;
  87   }
  88
  89   const auto& Info() const { return mInfo; }
  90 };
  91
  92 // -
  93
  94 class RangeProducerView final : public webgl::ProducerView<RangeProducerView> {
  95   const RangedPtr<uint8_t> mDestBegin;
  96   const RangedPtr<uint8_t> mDestEnd;
  97   RangedPtr<uint8_t> mDestItr;
  98
  99  public:
 100   auto Remaining() const { return *MaybeAs<size_t>(mDestEnd - mDestItr); }
 101
 102   explicit RangeProducerView(const Range<uint8_t> range)
 103       : ProducerView(this),
 104         mDestBegin(range.begin()),
 105         mDestEnd(range.end()),
 106         mDestItr(mDestBegin) {
 107     (void)Remaining();  // assert size non-negative
 108   }
 109
 110   template <typename T>
 111   bool WriteFromRange(const Range<const T>& src) {
 112     // uint32_t/float data may masquerade as a Range<uint8_t>.
 113     constexpr auto alignment = alignof(T);
 114     const size_t byteSize = ByteSize(src);
 115     // printf_stderr("RangeProducerView: @%zu +%zu\n", alignment, byteSize);
 116
 117     const auto padToAlign = AlignmentOffset(alignment, mDestItr.get());
 118     mDestItr += padToAlign;
 119
 120     MOZ_ASSERT(byteSize <= Remaining());
 121     if (MOZ_LIKELY(byteSize)) {
 122       memcpy(mDestItr.get(), src.begin().get(), byteSize);
 123     }
 124     mDestItr += byteSize;
 125     return true;
 126   }
 127 };
 128
 129 // -
 130
 131 template <typename ProducerViewT>
 132 inline void Serialize(ProducerViewT&) {}
 133
 134 template <typename ProducerViewT, typename Arg, typename... Args>
 135 inline void Serialize(ProducerViewT& view, const Arg& arg,
 136                       const Args&... args) {
 137   MOZ_ALWAYS_TRUE(view.WriteParam(arg));
 138   Serialize(view, args...);
 139 }
 140
 141 }  // namespace details
 142
 143 // -
 144
 145 template <typename... Args>
 146 auto SerializationInfo(const Args&... args) {
 147   webgl::details::SizeOnlyProducerView sizeView;
 148   webgl::details::Serialize(sizeView, args...);
 149   return sizeView.Info();
 150 }
 151
 152 template <typename... Args>
 153 void Serialize(Range<uint8_t> dest, const Args&... args) {
 154   webgl::details::RangeProducerView view(dest);
 155   webgl::details::Serialize(view, args...);
 156 }
 157
 158 // -
 159
 160 inline Maybe<uint16_t> Deserialize(RangeConsumerView&, size_t) { return {}; }
 161
 162 template <typename Arg, typename... Args>
 163 inline Maybe<uint16_t> Deserialize(RangeConsumerView& view,
 164                                    const uint16_t argId, Arg& arg,
 165                                    Args&... args) {
 166   if (!webgl::QueueParamTraits<Arg>::Read(view, &arg)) {
 167     return Some(argId);
 168   }
 169   return Deserialize(view, argId + 1, args...);
 170 }
 171
 172 }  // namespace webgl
 173
 174 // -
 175
 176 template <class R, class... Args>
 177 using fn_t = R(Args...);
 178
 179 // The MethodDispatcher setup uses a CommandSink to read parameters, call the
 180 // given method using the given synchronization protocol, and provide
 181 // compile-time lookup of the ID by class method.
 182 // To use this system, first define a dispatcher subclass of
 183 // EmptyMethodDispatcher.  This class must be parameterized by command ID.
 184 //
 185 // Example:
 186 // template <size_t id=0> class MyDispatcher
 187 //    : public EmptyMethodDispatcher<MyDispatcher> {};
 188 //
 189 // Then, for each command handled, specialize this to subclass MethodDispatcher.
 190 // The subclass must define the Method.  It may optionally define isSync for
 191 // synchronous methods.
 192 //
 193 // Example:
 194 // template <>
 195 // class MyDispatcher<0>
 196 //    : public MethodDispatcher<MyDispatcher, 0,
 197 //        decltype(&MyClass::MyMethod), MyClass::MyMethod> {};
 198 //
 199 // The method may then be called from the source and run on the sink.
 200 //
 201 // Example:
 202 // int result = Run<MyClass::MyMethod>(param1, std::move(param2));
 203
 204 template <template <size_t> typename Derived>
 205 class EmptyMethodDispatcher {
 206  public:
 207   template <typename ObjectT>
 208   static constexpr fn_t<bool, ObjectT&, webgl::RangeConsumerView&>*
 209   DispatchCommandFuncById(const size_t id) {
 210     return nullptr;
 211   }
 212 };
 213
 214 // -
 215
 216 template <typename ReturnT, typename ObjectT, typename... Args>
 217 std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> ArgsTuple(
 218     ReturnT (ObjectT::*)(Args... args)) {
 219   return std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>{};
 220 }
 221
 222 template <typename ReturnT, typename ObjectT, typename... Args>
 223 std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> ArgsTuple(
 224     ReturnT (ObjectT::*)(Args... args) const) {
 225   return std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>{};
 226 }
 227
 228 // Derived type must be parameterized by the ID.
 229 template <template <size_t> typename Derived, size_t _Id, typename MethodType,
 230           MethodType _Method>
 231 class MethodDispatcher {
 232   static constexpr auto Id = _Id;
 233   static constexpr auto Method = _Method;
 234   using DerivedType = Derived<Id>;
 235
 236  public:
 237   template <class ObjectT>
 238   static constexpr fn_t<bool, ObjectT&, webgl::RangeConsumerView&>*
 239   DispatchCommandFuncById(const size_t targetId) {
 240     if (targetId != Id)
 241       return Derived<Id + 1>::template DispatchCommandFuncById<ObjectT>(
 242           targetId);
 243
 244     return [](ObjectT& obj, webgl::RangeConsumerView& view) -> bool {
 245       const auto viewWas = view;
 246       (void)viewWas;  // For debugging.
 247
 248       auto argsTuple = ArgsTuple(Method);
 249       return std::apply(
 250           [&](auto&... args) {
 251             const auto badArgId = webgl::Deserialize(view, 1, args...);
 252             if (badArgId) {
 253               const auto& name = DerivedType::Name();
 254               gfxCriticalError() << "webgl::Deserialize failed for " << name
 255                                  << " arg " << *badArgId;
 256               return false;
 257             }
 258             (obj.*Method)(args...);
 259             return true;
 260           },
 261           argsTuple);
 262     };
 263   }
 264 };
 265
 266 }  // namespace mozilla
 267
 268 #endif  // WEBGLCOMMANDQUEUE_H_