ipc/glue/IdleSchedulerChild.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 "mozilla/ipc/IdleSchedulerChild.h"
   8 #include "mozilla/ipc/IdleSchedulerParent.h"
   9 #include "mozilla/ipc/PBackgroundChild.h"
  10 #include "mozilla/Atomics.h"
  11 #include "mozilla/IdlePeriodState.h"
  12 #include "mozilla/Telemetry.h"
  13 #include "BackgroundChild.h"
  14
  15 namespace mozilla::ipc {
  16
  17 static IdleSchedulerChild* sMainThreadIdleScheduler = nullptr;
  18 static bool sIdleSchedulerDestroyed = false;
  19
  20 IdleSchedulerChild::~IdleSchedulerChild() {
  21   if (sMainThreadIdleScheduler == this) {
  22     sMainThreadIdleScheduler = nullptr;
  23     sIdleSchedulerDestroyed = true;
  24   }
  25   MOZ_ASSERT(!mIdlePeriodState);
  26 }
  27
  28 void IdleSchedulerChild::Init(IdlePeriodState* aIdlePeriodState) {
  29   mIdlePeriodState = aIdlePeriodState;
  30
  31   RefPtr<IdleSchedulerChild> scheduler = this;
  32   auto resolve =
  33       [&](std::tuple<mozilla::Maybe<SharedMemoryHandle>, uint32_t>&& aResult) {
  34         if (std::get<0>(aResult)) {
  35           mActiveCounter.SetHandle(std::move(*std::get<0>(aResult)), false);
  36           mActiveCounter.Map(sizeof(int32_t));
  37           mChildId = std::get<1>(aResult);
  38           if (mChildId && mIdlePeriodState && mIdlePeriodState->IsActive()) {
  39             SetActive();
  40           }
  41         }
  42       };
  43
  44   auto reject = [&](ResponseRejectReason) {};
  45   SendInitForIdleUse(std::move(resolve), std::move(reject));
  46 }
  47
  48 IPCResult IdleSchedulerChild::RecvIdleTime(uint64_t aId, TimeDuration aBudget) {
  49   if (mIdlePeriodState) {
  50     mIdlePeriodState->SetIdleToken(aId, aBudget);
  51   }
  52   return IPC_OK();
  53 }
  54
  55 void IdleSchedulerChild::SetActive() {
  56   if (mChildId && CanSend() && mActiveCounter.memory()) {
  57     ++(static_cast<Atomic<int32_t>*>(
  58         mActiveCounter.memory())[NS_IDLE_SCHEDULER_INDEX_OF_ACTIVITY_COUNTER]);
  59     ++(static_cast<Atomic<int32_t>*>(mActiveCounter.memory())[mChildId]);
  60   }
  61 }
  62
  63 bool IdleSchedulerChild::SetPaused() {
  64   if (mChildId && CanSend() && mActiveCounter.memory()) {
  65     --(static_cast<Atomic<int32_t>*>(mActiveCounter.memory())[mChildId]);
  66     // The following expression reduces the global activity count and checks if
  67     // it drops below the cpu counter limit.
  68     return (static_cast<Atomic<int32_t>*>(
  69                mActiveCounter
  70                    .memory())[NS_IDLE_SCHEDULER_INDEX_OF_ACTIVITY_COUNTER])-- ==
  71            static_cast<Atomic<int32_t>*>(
  72                mActiveCounter.memory())[NS_IDLE_SCHEDULER_INDEX_OF_CPU_COUNTER];
  73   }
  74
  75   return false;
  76 }
  77
  78 RefPtr<IdleSchedulerChild::MayGCPromise> IdleSchedulerChild::MayGCNow() {
  79   if (mIsRequestingGC || mIsDoingGC) {
  80     return MayGCPromise::CreateAndResolve(false, __func__);
  81   }
  82   TimeStamp wait_since = TimeStamp::Now();
  83
  84   mIsRequestingGC = true;
  85   return SendRequestGC()->Then(
  86       GetMainThreadSerialEventTarget(), __func__,
  87       [self = RefPtr(this), wait_since](bool aIgnored) {
  88         // Only one of these may be true at a time.
  89         MOZ_ASSERT(!(self->mIsRequestingGC && self->mIsDoingGC));
  90
  91         // The parent process always says yes, sometimes after a delay.
  92         if (self->mIsRequestingGC) {
  93           Telemetry::AccumulateTimeDelta(Telemetry::GC_WAIT_FOR_IDLE_MS,
  94                                          wait_since);
  95           self->mIsRequestingGC = false;
  96           self->mIsDoingGC = true;
  97           return MayGCPromise::CreateAndResolve(true, __func__);
  98         }
  99         return MayGCPromise::CreateAndResolve(false, __func__);
 100       },
 101       [self = RefPtr(this)](ResponseRejectReason reason) {
 102         self->mIsRequestingGC = false;
 103         return MayGCPromise::CreateAndReject(reason, __func__);
 104       });
 105 }
 106
 107 void IdleSchedulerChild::StartedGC() {
 108   // Only one of these may be true at a time.
 109   MOZ_ASSERT(!(mIsRequestingGC && mIsDoingGC));
 110
 111   // If mRequestingGC was true then when the outstanding GC request returns
 112   // it'll see that the GC has already started.
 113   mIsRequestingGC = false;
 114
 115   if (!mIsDoingGC) {
 116     if (CanSend()) {
 117       SendStartedGC();
 118     }
 119     mIsDoingGC = true;
 120   }
 121 }
 122
 123 void IdleSchedulerChild::DoneGC() {
 124   if (mIsDoingGC) {
 125     if (CanSend()) {
 126       SendDoneGC();
 127     }
 128     mIsDoingGC = false;
 129   }
 130 }
 131
 132 IdleSchedulerChild* IdleSchedulerChild::GetMainThreadIdleScheduler() {
 133   MOZ_ASSERT(NS_IsMainThread());
 134
 135   if (sMainThreadIdleScheduler) {
 136     return sMainThreadIdleScheduler;
 137   }
 138
 139   if (sIdleSchedulerDestroyed) {
 140     return nullptr;
 141   }
 142
 143   ipc::PBackgroundChild* background =
 144       ipc::BackgroundChild::GetOrCreateForCurrentThread();
 145   if (background) {
 146     sMainThreadIdleScheduler = new ipc::IdleSchedulerChild();
 147     background->SendPIdleSchedulerConstructor(sMainThreadIdleScheduler);
 148   }
 149   return sMainThreadIdleScheduler;
 150 }
 151
 152 }  // namespace mozilla::ipc