gfx/layers/CanvasDrawEventRecorder.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "CanvasDrawEventRecorder.h"
   8
   9 #include <string.h>
  10
  11 #include "mozilla/dom/WorkerCommon.h"
  12 #include "mozilla/dom/WorkerPrivate.h"
  13 #include "mozilla/dom/WorkerRef.h"
  14 #include "mozilla/dom/WorkerRunnable.h"
  15 #include "mozilla/layers/TextureRecorded.h"
  16 #include "mozilla/layers/SharedSurfacesChild.h"
  17 #include "mozilla/StaticPrefs_gfx.h"
  18 #include "RecordedCanvasEventImpl.h"
  19
  20 namespace mozilla {
  21 namespace layers {
  22
  23 struct ShmemAndHandle {
  24   RefPtr<ipc::SharedMemoryBasic> shmem;
  25   Handle handle;
  26 };
  27
  28 static Maybe<ShmemAndHandle> CreateAndMapShmem(size_t aSize) {
  29   auto shmem = MakeRefPtr<ipc::SharedMemoryBasic>();
  30   if (!shmem->Create(aSize) || !shmem->Map(aSize)) {
  31     return Nothing();
  32   }
  33
  34   auto shmemHandle = shmem->TakeHandle();
  35   if (!shmemHandle) {
  36     return Nothing();
  37   }
  38
  39   return Some(ShmemAndHandle{shmem.forget(), std::move(shmemHandle)});
  40 }
  41
  42 CanvasDrawEventRecorder::CanvasDrawEventRecorder(
  43     dom::ThreadSafeWorkerRef* aWorkerRef)
  44     : mWorkerRef(aWorkerRef), mIsOnWorker(!!aWorkerRef) {
  45   mDefaultBufferSize = ipc::SharedMemory::PageAlignedSize(
  46       StaticPrefs::gfx_canvas_remote_default_buffer_size());
  47   mMaxDefaultBuffers = StaticPrefs::gfx_canvas_remote_max_default_buffers();
  48   mMaxSpinCount = StaticPrefs::gfx_canvas_remote_max_spin_count();
  49   mDropBufferLimit = StaticPrefs::gfx_canvas_remote_drop_buffer_limit();
  50   mDropBufferOnZero = mDropBufferLimit;
  51 }
  52
  53 CanvasDrawEventRecorder::~CanvasDrawEventRecorder() { MOZ_ASSERT(!mWorkerRef); }
  54
  55 bool CanvasDrawEventRecorder::Init(TextureType aTextureType,
  56                                    TextureType aWebglTextureType,
  57                                    gfx::BackendType aBackendType,
  58                                    UniquePtr<Helpers> aHelpers) {
  59   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
  60
  61   mHelpers = std::move(aHelpers);
  62
  63   MOZ_ASSERT(mTextureType == TextureType::Unknown);
  64   auto header = CreateAndMapShmem(sizeof(Header));
  65   if (NS_WARN_IF(header.isNothing())) {
  66     return false;
  67   }
  68
  69   mHeader = static_cast<Header*>(header->shmem->memory());
  70   mHeader->eventCount = 0;
  71   mHeader->writerWaitCount = 0;
  72   mHeader->writerState = State::Processing;
  73   mHeader->processedCount = 0;
  74   mHeader->readerState = State::Paused;
  75
  76   // We always keep at least two buffers. This means that when we
  77   // have to add a new buffer, there is at least a full buffer that requires
  78   // translating while the handle is sent over.
  79   AutoTArray<Handle, 2> bufferHandles;
  80   auto buffer = CreateAndMapShmem(mDefaultBufferSize);
  81   if (NS_WARN_IF(buffer.isNothing())) {
  82     return false;
  83   }
  84   mCurrentBuffer = CanvasBuffer(std::move(buffer->shmem));
  85   bufferHandles.AppendElement(std::move(buffer->handle));
  86
  87   buffer = CreateAndMapShmem(mDefaultBufferSize);
  88   if (NS_WARN_IF(buffer.isNothing())) {
  89     return false;
  90   }
  91   mRecycledBuffers.emplace(buffer->shmem.forget(), 0);
  92   bufferHandles.AppendElement(std::move(buffer->handle));
  93
  94   mWriterSemaphore.reset(CrossProcessSemaphore::Create("CanvasRecorder", 0));
  95   auto writerSem = mWriterSemaphore->CloneHandle();
  96   mWriterSemaphore->CloseHandle();
  97   if (!IsHandleValid(writerSem)) {
  98     return false;
  99   }
 100
 101   mReaderSemaphore.reset(CrossProcessSemaphore::Create("CanvasTranslator", 0));
 102   auto readerSem = mReaderSemaphore->CloneHandle();
 103   mReaderSemaphore->CloseHandle();
 104   if (!IsHandleValid(readerSem)) {
 105     return false;
 106   }
 107
 108   if (!mHelpers->InitTranslator(aTextureType, aWebglTextureType, aBackendType,
 109                                 std::move(header->handle),
 110                                 std::move(bufferHandles), mDefaultBufferSize,
 111                                 std::move(readerSem), std::move(writerSem))) {
 112     return false;
 113   }
 114
 115   mTextureType = aTextureType;
 116   mHeaderShmem = header->shmem;
 117   return true;
 118 }
 119
 120 void CanvasDrawEventRecorder::RecordEvent(const gfx::RecordedEvent& aEvent) {
 121   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
 122   aEvent.RecordToStream(*this);
 123 }
 124
 125 int64_t CanvasDrawEventRecorder::CreateCheckpoint() {
 126   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
 127   int64_t checkpoint = mHeader->eventCount;
 128   RecordEvent(RecordedCheckpoint());
 129   ClearProcessedExternalSurfaces();
 130   ClearProcessedExternalImages();
 131   return checkpoint;
 132 }
 133
 134 bool CanvasDrawEventRecorder::WaitForCheckpoint(int64_t aCheckpoint) {
 135   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
 136
 137   uint32_t spinCount = mMaxSpinCount;
 138   do {
 139     if (mHeader->processedCount >= aCheckpoint) {
 140       return true;
 141     }
 142   } while (--spinCount != 0);
 143
 144   mHeader->writerState = State::AboutToWait;
 145   if (mHeader->processedCount >= aCheckpoint) {
 146     mHeader->writerState = State::Processing;
 147     return true;
 148   }
 149
 150   mHeader->writerWaitCount = aCheckpoint;
 151   mHeader->writerState = State::Waiting;
 152
 153   // Wait unless we detect the reading side has closed.
 154   while (!mHelpers->ReaderClosed() && mHeader->readerState != State::Failed) {
 155     if (mWriterSemaphore->Wait(Some(TimeDuration::FromMilliseconds(100)))) {
 156       MOZ_ASSERT(mHeader->processedCount >= aCheckpoint);
 157       return true;
 158     }
 159   }
 160
 161   // Either the reader has failed or we're stopping writing for some other
 162   // reason (e.g. shutdown), so mark us as failed so the reader is aware.
 163   mHeader->writerState = State::Failed;
 164   return false;
 165 }
 166
 167 void CanvasDrawEventRecorder::WriteInternalEvent(EventType aEventType) {
 168   MOZ_ASSERT(mCurrentBuffer.SizeRemaining() > 0);
 169
 170   WriteElement(mCurrentBuffer.Writer(), aEventType);
 171   IncrementEventCount();
 172 }
 173
 174 gfx::ContiguousBuffer& CanvasDrawEventRecorder::GetContiguousBuffer(
 175     size_t aSize) {
 176   if (!mCurrentBuffer.IsValid()) {
 177     // If the current buffer is invalid then we've already failed previously.
 178     MOZ_ASSERT(mHeader->writerState == State::Failed);
 179     return mCurrentBuffer;
 180   }
 181
 182   // We make sure that our buffer can hold aSize + 1 to ensure we always have
 183   // room for the end of buffer event.
 184
 185   // Check if there is enough room is our current buffer.
 186   if (mCurrentBuffer.SizeRemaining() > aSize) {
 187     return mCurrentBuffer;
 188   }
 189
 190   bool useRecycledBuffer = false;
 191   if (mRecycledBuffers.front().Capacity() > aSize) {
 192     // The recycled buffer is big enough, check if it is free.
 193     if (mRecycledBuffers.front().eventCount <= mHeader->processedCount) {
 194       useRecycledBuffer = true;
 195     } else if (mRecycledBuffers.size() >= mMaxDefaultBuffers) {
 196       // We've hit he max number of buffers, wait for the next one to be free.
 197       // We wait for (eventCount - 1), as we check and signal in the translator
 198       // during the play event, before the processedCount has been updated.
 199       useRecycledBuffer = true;
 200       if (!WaitForCheckpoint(mRecycledBuffers.front().eventCount - 1)) {
 201         // The wait failed or we're shutting down, just return an empty buffer.
 202         mCurrentBuffer = CanvasBuffer();
 203         return mCurrentBuffer;
 204       }
 205     }
 206   }
 207
 208   if (useRecycledBuffer) {
 209     // Only queue default size buffers for recycling.
 210     if (mCurrentBuffer.Capacity() == mDefaultBufferSize) {
 211       WriteInternalEvent(RECYCLE_BUFFER);
 212       mRecycledBuffers.emplace(std::move(mCurrentBuffer.shmem),
 213                                mHeader->eventCount);
 214     } else {
 215       WriteInternalEvent(DROP_BUFFER);
 216     }
 217
 218     mCurrentBuffer = CanvasBuffer(std::move(mRecycledBuffers.front().shmem));
 219     mRecycledBuffers.pop();
 220
 221     // If we have more than one recycled buffers free a configured number of
 222     // times in a row then drop one.
 223     if (mRecycledBuffers.size() > 1 &&
 224         mRecycledBuffers.front().eventCount < mHeader->processedCount) {
 225       if (--mDropBufferOnZero == 0) {
 226         WriteInternalEvent(DROP_BUFFER);
 227         mCurrentBuffer =
 228             CanvasBuffer(std::move(mRecycledBuffers.front().shmem));
 229         mRecycledBuffers.pop();
 230         mDropBufferOnZero = 1;
 231       }
 232     } else {
 233       mDropBufferOnZero = mDropBufferLimit;
 234     }
 235
 236     return mCurrentBuffer;
 237   }
 238
 239   // We don't have a buffer free or it is not big enough, so create a new one.
 240   WriteInternalEvent(PAUSE_TRANSLATION);
 241
 242   // Only queue default size buffers for recycling.
 243   if (mCurrentBuffer.Capacity() == mDefaultBufferSize) {
 244     mRecycledBuffers.emplace(std::move(mCurrentBuffer.shmem),
 245                              mHeader->eventCount);
 246   }
 247
 248   size_t bufferSize = std::max(mDefaultBufferSize,
 249                                ipc::SharedMemory::PageAlignedSize(aSize + 1));
 250   auto newBuffer = CreateAndMapShmem(bufferSize);
 251   if (NS_WARN_IF(newBuffer.isNothing())) {
 252     mHeader->writerState = State::Failed;
 253     mCurrentBuffer = CanvasBuffer();
 254     return mCurrentBuffer;
 255   }
 256
 257   if (!mHelpers->AddBuffer(std::move(newBuffer->handle), bufferSize)) {
 258     mHeader->writerState = State::Failed;
 259     mCurrentBuffer = CanvasBuffer();
 260     return mCurrentBuffer;
 261   }
 262
 263   mCurrentBuffer = CanvasBuffer(std::move(newBuffer->shmem));
 264   return mCurrentBuffer;
 265 }
 266
 267 void CanvasDrawEventRecorder::DropFreeBuffers() {
 268   while (mRecycledBuffers.size() > 1 &&
 269          mRecycledBuffers.front().eventCount < mHeader->processedCount) {
 270     // If we encountered an error, we may have invalidated mCurrentBuffer in
 271     // GetContiguousBuffer. No need to write the DROP_BUFFER event.
 272     if (mCurrentBuffer.IsValid()) {
 273       WriteInternalEvent(DROP_BUFFER);
 274     }
 275     mCurrentBuffer = CanvasBuffer(std::move(mRecycledBuffers.front().shmem));
 276     mRecycledBuffers.pop();
 277   }
 278
 279   ClearProcessedExternalSurfaces();
 280   ClearProcessedExternalImages();
 281 }
 282
 283 void CanvasDrawEventRecorder::IncrementEventCount() {
 284   mHeader->eventCount++;
 285   CheckAndSignalReader();
 286 }
 287
 288 void CanvasDrawEventRecorder::CheckAndSignalReader() {
 289   do {
 290     switch (mHeader->readerState) {
 291       case State::Processing:
 292       case State::Paused:
 293       case State::Failed:
 294         return;
 295       case State::AboutToWait:
 296         // The reader is making a decision about whether to wait. So, we must
 297         // wait until it has decided to avoid races. Check if the reader is
 298         // closed to avoid hangs.
 299         if (mHelpers->ReaderClosed()) {
 300           return;
 301         }
 302         continue;
 303       case State::Waiting:
 304         if (mHeader->processedCount < mHeader->eventCount) {
 305           // We have to use compareExchange here because the reader can change
 306           // from Waiting to Stopped.
 307           if (mHeader->readerState.compareExchange(State::Waiting,
 308                                                    State::Processing)) {
 309             mReaderSemaphore->Signal();
 310             return;
 311           }
 312
 313           MOZ_ASSERT(mHeader->readerState == State::Stopped);
 314           continue;
 315         }
 316         return;
 317       case State::Stopped:
 318         if (mHeader->processedCount < mHeader->eventCount) {
 319           mHeader->readerState = State::Processing;
 320           if (!mHelpers->RestartReader()) {
 321             mHeader->writerState = State::Failed;
 322           }
 323         }
 324         return;
 325       default:
 326         MOZ_ASSERT_UNREACHABLE("Invalid waiting state.");
 327         return;
 328     }
 329   } while (true);
 330 }
 331
 332 void CanvasDrawEventRecorder::DetachResources() {
 333   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
 334
 335   DrawEventRecorderPrivate::DetachResources();
 336
 337   {
 338     auto lockedPendingDeletions = mPendingDeletions.Lock();
 339     mWorkerRef = nullptr;
 340   }
 341 }
 342
 343 void CanvasDrawEventRecorder::QueueProcessPendingDeletionsLocked(
 344     RefPtr<CanvasDrawEventRecorder>&& aRecorder) {
 345   if (!mWorkerRef) {
 346     MOZ_RELEASE_ASSERT(
 347         !mIsOnWorker,
 348         "QueueProcessPendingDeletionsLocked called after worker shutdown!");
 349
 350     NS_DispatchToMainThread(NS_NewRunnableFunction(
 351         "CanvasDrawEventRecorder::QueueProcessPendingDeletionsLocked",
 352         [self = std::move(aRecorder)]() { self->ProcessPendingDeletions(); }));
 353     return;
 354   }
 355
 356   if (!NS_IsMainThread()) {
 357     NS_DispatchToMainThread(NS_NewRunnableFunction(
 358         "CanvasDrawEventRecorder::QueueProcessPendingDeletionsLocked",
 359         [self = std::move(aRecorder)]() mutable {
 360           self->QueueProcessPendingDeletions(std::move(self));
 361         }));
 362     return;
 363   }
 364
 365   class ProcessPendingRunnable final : public dom::WorkerRunnable {
 366    public:
 367     ProcessPendingRunnable(dom::WorkerPrivate* aWorkerPrivate,
 368                            RefPtr<CanvasDrawEventRecorder>&& aRecorder)
 369         : dom::WorkerRunnable(aWorkerPrivate),
 370           mRecorder(std::move(aRecorder)) {}
 371
 372     bool WorkerRun(JSContext*, dom::WorkerPrivate*) override {
 373       RefPtr<CanvasDrawEventRecorder> recorder = std::move(mRecorder);
 374       recorder->ProcessPendingDeletions();
 375       return true;
 376     }
 377
 378    private:
 379     RefPtr<CanvasDrawEventRecorder> mRecorder;
 380   };
 381
 382   auto task = MakeRefPtr<ProcessPendingRunnable>(mWorkerRef->Private(),
 383                                                  std::move(aRecorder));
 384   if (NS_WARN_IF(!task->Dispatch())) {
 385     MOZ_CRASH("ProcessPendingRunnable leaked!");
 386   }
 387 }
 388
 389 void CanvasDrawEventRecorder::QueueProcessPendingDeletions(
 390     RefPtr<CanvasDrawEventRecorder>&& aRecorder) {
 391   auto lockedPendingDeletions = mPendingDeletions.Lock();
 392   if (lockedPendingDeletions->empty()) {
 393     // We raced to handle the deletions, and something got there first.
 394     return;
 395   }
 396
 397   QueueProcessPendingDeletionsLocked(std::move(aRecorder));
 398 }
 399
 400 void CanvasDrawEventRecorder::AddPendingDeletion(
 401     std::function<void()>&& aPendingDeletion) {
 402   PendingDeletionsVector pendingDeletions;
 403
 404   {
 405     auto lockedPendingDeletions = mPendingDeletions.Lock();
 406     bool wasEmpty = lockedPendingDeletions->empty();
 407     lockedPendingDeletions->emplace_back(std::move(aPendingDeletion));
 408
 409     MOZ_RELEASE_ASSERT(!mIsOnWorker || mWorkerRef,
 410                        "AddPendingDeletion called after worker shutdown!");
 411
 412     // If we are not on the owning thread, we must queue an event to run the
 413     // deletions, if we transitioned from empty to non-empty.
 414     if ((mWorkerRef && !mWorkerRef->Private()->IsOnCurrentThread()) ||
 415         (!mWorkerRef && !NS_IsMainThread())) {
 416       if (wasEmpty) {
 417         RefPtr<CanvasDrawEventRecorder> self(this);
 418         QueueProcessPendingDeletionsLocked(std::move(self));
 419       }
 420       return;
 421     }
 422
 423     // Otherwise, we can just run all of them right now.
 424     pendingDeletions.swap(*lockedPendingDeletions);
 425   }
 426
 427   for (const auto& pendingDeletion : pendingDeletions) {
 428     pendingDeletion();
 429   }
 430 }
 431
 432 void CanvasDrawEventRecorder::StoreSourceSurfaceRecording(
 433     gfx::SourceSurface* aSurface, const char* aReason) {
 434   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
 435
 436   if (NS_IsMainThread()) {
 437     wr::ExternalImageId extId{};
 438     nsresult rv = layers::SharedSurfacesChild::Share(aSurface, extId);
 439     if (NS_SUCCEEDED(rv)) {
 440       StoreExternalSurfaceRecording(aSurface, wr::AsUint64(extId));
 441       mExternalSurfaces.back().mEventCount = mHeader->eventCount;
 442       return;
 443     }
 444   }
 445
 446   DrawEventRecorderPrivate::StoreSourceSurfaceRecording(aSurface, aReason);
 447 }
 448
 449 void CanvasDrawEventRecorder::StoreImageRecording(
 450     const RefPtr<Image>& aImageOfSurfaceDescriptor, const char* aReasony) {
 451   NS_ASSERT_OWNINGTHREAD(CanvasDrawEventRecorder);
 452
 453   StoreExternalImageRecording(aImageOfSurfaceDescriptor);
 454   mExternalImages.back().mEventCount = mHeader->eventCount;
 455
 456   ClearProcessedExternalImages();
 457 }
 458
 459 void CanvasDrawEventRecorder::ClearProcessedExternalSurfaces() {
 460   while (!mExternalSurfaces.empty()) {
 461     if (mExternalSurfaces.front().mEventCount > mHeader->processedCount) {
 462       break;
 463     }
 464     mExternalSurfaces.pop_front();
 465   }
 466 }
 467
 468 void CanvasDrawEventRecorder::ClearProcessedExternalImages() {
 469   while (!mExternalImages.empty()) {
 470     if (mExternalImages.front().mEventCount > mHeader->processedCount) {
 471       break;
 472     }
 473     mExternalImages.pop_front();
 474   }
 475 }
 476
 477 }  // namespace layers
 478 }  // namespace mozilla