Quelle  GCParallelTask.cpp   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gc/GCParallelTask.h"

#include "mozilla/Maybe.h"
#include "mozilla/TimeStamp.h"

#include "gc/GCContext.h"
#include "gc/GCInternals.h"
#include "gc/ParallelWork.h"
#include "vm/HelperThreadState.h"
#include "vm/Runtime.h"
#include "vm/Time.h"

using namespace js;
using namespace js::gc;

using mozilla::Maybe;
using mozilla::TimeDuration;
using mozilla::TimeStamp;

js::GCParallelTask::~GCParallelTask() {
  // The LinkedListElement destructor will remove us from any list we are part
  // of without synchronization, so ensure that doesn't happen.
  MOZ_DIAGNOSTIC_ASSERT(!isInList());

  // Only most-derived classes' destructors may do the join: base class
  // destructors run after those for derived classes' members, so a join in a
  // base class can't ensure that the task is done using the members. All we
  // can do now is check that someone has previously stopped the task.
  assertIdle();
}

static bool ShouldMeasureTaskStartDelay() {
  // We use many tasks during GC so randomly sample a small fraction for the
  // purposes of recording telemetry.
  return (rand() % 100) == 0;
}

void js::GCParallelTask::startWithLockHeld(AutoLockHelperThreadState& lock) {
  MOZ_ASSERT(CanUseExtraThreads());
  MOZ_ASSERT(HelperThreadState().isInitialized(lock));
  assertIdle();

  maybeQueueTime_ = TimeStamp();
  if (ShouldMeasureTaskStartDelay()) {
    maybeQueueTime_ = TimeStamp::Now();
  }

  dispatchedToThreadPool = false;

  gc->dispatchOrQueueParallelTask(this, lock);
}

void js::GCParallelTask::start() {
  if (!CanUseExtraThreads()) {
    runFromMainThread();
    return;
  }

  AutoLockHelperThreadState lock;
  startWithLockHeld(lock);
}

void js::GCParallelTask::startOrRunIfIdle(AutoLockHelperThreadState& lock) {
  if (wasStarted(lock)) {
    return;
  }

  // Join the previous invocation of the task. This will return immediately
  // if the thread has never been started.
  joinWithLockHeld(lock);

  if (!CanUseExtraThreads()) {
    runFromMainThread(lock);
    return;
  }

  startWithLockHeld(lock);
}

void js::GCParallelTask::cancelAndWait() {
  MOZ_ASSERT(!isCancelled());
  cancel_ = true;
  join();
  cancel_ = false;
}

void js::GCParallelTask::join(Maybe<TimeStamp> deadline) {
  AutoLockHelperThreadState lock;
  joinWithLockHeld(lock, deadline);
}

void js::GCParallelTask::joinWithLockHeld(AutoLockHelperThreadState& lock,
                                          Maybe<TimeStamp> deadline) {
  // Task has not been started; there's nothing to do.
  if (isIdle(lock)) {
    return;
  }

  if (lock.hasQueuedTasks()) {
    // Unlock to allow task dispatch without lock held, otherwise we could wait
    // forever.
    AutoUnlockHelperThreadState unlock(lock);
  }

  if (isNotYetRunning(lock) && !dispatchedToThreadPool &&
      deadline.isNothing()) {
    // If the task was dispatched but has not yet started then cancel the task
    // and run it from the main thread. This stops us from blocking here when
    // the helper threads are busy with other tasks.
    MOZ_ASSERT(isInList());
    MOZ_ASSERT_IF(isDispatched(lock), gc->dispatchedParallelTasks != 0);

    remove();
    runFromMainThread(lock);
  } else {
    // Otherwise wait for the task to complete.
    joinNonIdleTask(deadline, lock);
  }

  if (isIdle(lock)) {
    recordDuration();
  }
}

void GCParallelTask::recordDuration() {
  if (phaseKind != gcstats::PhaseKind::NONE) {
    gc->stats().recordParallelPhase(phaseKind, duration_);
  }
}

void js::GCParallelTask::joinNonIdleTask(Maybe<TimeStamp> deadline,
                                         AutoLockHelperThreadState& lock) {
  MOZ_ASSERT(!isIdle(lock));

  while (!isFinished(lock)) {
    TimeDuration timeout = TimeDuration::Forever();
    if (deadline) {
      TimeStamp now = TimeStamp::Now();
      if (*deadline <= now) {
        break;
      }
      timeout = *deadline - now;
    }

    HelperThreadState().wait(lock, timeout);
  }

  if (isFinished(lock)) {
    setIdle(lock);
  }
}

void js::GCParallelTask::runFromMainThread() {
  AutoLockHelperThreadState lock;
  runFromMainThread(lock);
}

void js::GCParallelTask::runFromMainThread(AutoLockHelperThreadState& lock) {
  MOZ_ASSERT(isNotYetRunning(lock));
  MOZ_ASSERT(js::CurrentThreadCanAccessRuntime(gc->rt));

  if (lock.hasQueuedTasks()) {
    // Unlock to allow task dispatch without lock held, otherwise we can wait
    // forever.
    AutoUnlockHelperThreadState unlock(lock);
  }

  runTask(gc->rt->gcContext(), lock);
  setIdle(lock);
}

class MOZ_RAII AutoGCContext {
  JS::GCContext context;

 public:
  explicit AutoGCContext(JSRuntime* runtime) : context(runtime) {
    MOZ_RELEASE_ASSERT(TlsGCContext.init(),
                       "Failed to initialize TLS for GC context");

    MOZ_ASSERT(!TlsGCContext.get());
    TlsGCContext.set(&context);
  }

  ~AutoGCContext() {
    MOZ_ASSERT(TlsGCContext.get() == &context);
    TlsGCContext.set(nullptr);
  }

  JS::GCContext* get() { return &context; }
};

void js::GCParallelTask::runHelperThreadTask(AutoLockHelperThreadState& lock) {
  AutoGCContext gcContext(gc->rt);
  runTask(gcContext.get(), lock);
  MOZ_ASSERT(isFinished(lock));
}

void GCParallelTask::runTask(JS::GCContext* gcx,
                             AutoLockHelperThreadState& lock) {
  // Run the task from either the main thread or a helper thread.

  bool wasDispatched = isDispatched(lock);
  setRunning(lock);

  AutoSetThreadGCUse setUse(gcx, use);

  // The hazard analysis can't tell what the call to func_ will do but it's not
  // allowed to GC.
  JS::AutoSuppressGCAnalysis nogc;

  TimeStamp timeStart = TimeStamp::Now();
  run(lock);
  duration_ = TimeSince(timeStart);

  if (maybeQueueTime_) {
    TimeDuration delay = timeStart - maybeQueueTime_;
    gc->rt->metrics().GC_TASK_START_DELAY_US(delay);
  }

  setFinished(lock);
  gc->onParallelTaskEnd(wasDispatched, lock);
}

void GCParallelTask::onThreadPoolDispatch() {
  MOZ_ASSERT(!dispatchedToThreadPool);
  dispatchedToThreadPool = true;
}

void GCRuntime::dispatchOrQueueParallelTask(
    GCParallelTask* task, const AutoLockHelperThreadState& lock) {
  task->setQueued(lock);
  queuedParallelTasks.ref().insertBack(task, lock);
  maybeDispatchParallelTasks(lock);
}

void GCRuntime::maybeDispatchParallelTasks(
    const AutoLockHelperThreadState& lock) {
  MOZ_ASSERT(maxParallelThreads != 0);
  MOZ_ASSERT(dispatchedParallelTasks <= maxParallelThreads);

  while (dispatchedParallelTasks < maxParallelThreads &&
         !queuedParallelTasks.ref().isEmpty(lock)) {
    GCParallelTask* task = queuedParallelTasks.ref().popFirst(lock);
    task->setDispatched(lock);
    HelperThreadState().submitTask(task, lock);
    dispatchedParallelTasks++;
  }
}

void GCRuntime::onParallelTaskEnd(bool wasDispatched,
                                  const AutoLockHelperThreadState& lock) {
  if (wasDispatched) {
    MOZ_ASSERT(dispatchedParallelTasks != 0);
    dispatchedParallelTasks--;
  }
  maybeDispatchParallelTasks(lock);
}

bool js::GCParallelTask::isIdle() const {
  AutoLockHelperThreadState lock;
  return isIdle(lock);
}

bool js::GCParallelTask::wasStarted() const {
  AutoLockHelperThreadState lock;
  return wasStarted(lock);
}

/* static */
size_t js::gc::GCRuntime::parallelWorkerCount() const {
  return std::min(helperThreadCount.ref(), MaxParallelWorkers);
}