Bug 1449135 part 3 - Remove cooperative scheduling; bake in JSContext* in JIT code. r=luke

Author: jandem

js/public/RootingAPI.h

@@ -874,8 +874,8 @@ class JS_PUBLIC_API(AutoGCRooter)
 
     /* Implemented in gc/RootMarking.cpp. */
     inline void trace(JSTracer* trc);
-    static void traceAll(const js::CooperatingContext& target, JSTracer* trc);
-    static void traceAllWrappers(const js::CooperatingContext& target, JSTracer* trc);
+    static void traceAll(JSContext* cx, JSTracer* trc);
+    static void traceAllWrappers(JSContext* cx, JSTracer* trc);
 
   protected:
     AutoGCRooter * const down;

js/src/gc/GC.cpp

@@ -3244,7 +3244,7 @@ GCRuntime::triggerGC(JS::gcreason::Reason reason)
     if (JS::CurrentThreadIsHeapCollecting())
         return false;
 
-    JS::PrepareForFullGC(rt->activeContextFromOwnThread());
+    JS::PrepareForFullGC(rt->mainContextFromOwnThread());
     requestMajorGC(reason);
     return true;
 }
@@ -3341,7 +3341,7 @@ GCRuntime::maybeGC(Zone* zone)
 
 #ifdef JS_GC_ZEAL
     if (hasZealMode(ZealMode::Alloc) || hasZealMode(ZealMode::RootsChange)) {
-        JS::PrepareForFullGC(rt->activeContextFromOwnThread());
+        JS::PrepareForFullGC(rt->mainContextFromOwnThread());
         gc(GC_NORMAL, JS::gcreason::DEBUG_GC);
         return;
     }
@@ -3966,11 +3966,10 @@ GCRuntime::purgeRuntime()
         zone->functionToStringCache().purge();
     }
 
-    for (const CooperatingContext& target : rt->cooperatingContexts()) {
-        freeUnusedLifoBlocksAfterSweeping(&target.context()->tempLifoAlloc());
-        target.context()->interpreterStack().purge(rt);
-        target.context()->frontendCollectionPool().purge();
-    }
+    JSContext* cx = rt->mainContextFromOwnThread();
+    freeUnusedLifoBlocksAfterSweeping(&cx->tempLifoAlloc());
+    cx->interpreterStack().purge(rt);
+    cx->frontendCollectionPool().purge();
 
     rt->caches().purge();
 
@@ -7020,8 +7019,7 @@ GCRuntime::incrementalCollectSlice(SliceBudget& budget, JS::gcreason::Reason rea
         MOZ_FALLTHROUGH;
 
       case State::Mark:
-        for (const CooperatingContext& target : rt->cooperatingContexts())
-            AutoGCRooter::traceAllWrappers(target, &marker);
+        AutoGCRooter::traceAllWrappers(rt->mainContextFromOwnThread(), &marker);
 
         /* If we needed delayed marking for gray roots, then collect until done. */
         if (isIncremental && !hasValidGrayRootsBuffer()) {
@@ -7468,7 +7466,7 @@ GCRuntime::maybeDoCycleCollection()
     }
     double grayFraction = double(compartmentsGray) / double(compartmentsTotal);
     if (grayFraction > ExcessiveGrayCompartments || compartmentsGray > LimitGrayCompartments)
-        callDoCycleCollectionCallback(rt->activeContextFromOwnThread());
+        callDoCycleCollectionCallback(rt->mainContextFromOwnThread());
 }
 
 void
@@ -7556,7 +7554,7 @@ GCRuntime::collect(bool nonincrementalByAPI, SliceBudget budget, JS::gcreason::R
                 repeat = true;
             } else if (rootsRemoved && IsShutdownGC(reason)) {
                 /* Need to re-schedule all zones for GC. */
-                JS::PrepareForFullGC(rt->activeContextFromOwnThread());
+                JS::PrepareForFullGC(rt->mainContextFromOwnThread());
                 repeat = true;
                 reason = JS::gcreason::ROOTS_REMOVED;
             } else if (shouldRepeatForDeadZone(reason)) {
@@ -7672,7 +7670,7 @@ GCRuntime::startDebugGC(JSGCInvocationKind gckind, SliceBudget& budget)
 {
     MOZ_ASSERT(!isIncrementalGCInProgress());
     if (!ZonesSelected(rt))
-        JS::PrepareForFullGC(rt->activeContextFromOwnThread());
+        JS::PrepareForFullGC(rt->mainContextFromOwnThread());
     invocationKind = gckind;
     collect(false, budget, JS::gcreason::DEBUG_GC);
 }
@@ -7682,7 +7680,7 @@ GCRuntime::debugGCSlice(SliceBudget& budget)
 {
     MOZ_ASSERT(isIncrementalGCInProgress());
     if (!ZonesSelected(rt))
-        JS::PrepareForIncrementalGC(rt->activeContextFromOwnThread());
+        JS::PrepareForIncrementalGC(rt->mainContextFromOwnThread());
     collect(false, budget, JS::gcreason::DEBUG_GC);
 }
 
@@ -7691,7 +7689,7 @@ void
 js::PrepareForDebugGC(JSRuntime* rt)
 {
     if (!ZonesSelected(rt))
-        JS::PrepareForFullGC(rt->activeContextFromOwnThread());
+        JS::PrepareForFullGC(rt->mainContextFromOwnThread());
 }
 
 void
@@ -7864,10 +7862,7 @@ js::NewCompartment(JSContext* cx, JSPrincipals* principals,
         break;
     }
 
-    if (group) {
-        // Take over ownership of the group while we create the compartment/zone.
-        group->enter(cx);
-    } else {
+    if (!group) {
         MOZ_ASSERT(!zone);
         group = cx->new_<ZoneGroup>(rt);
         if (!group)
@@ -7937,13 +7932,11 @@ js::NewCompartment(JSContext* cx, JSPrincipals* principals,
         if (zoneSpec == JS::SystemZone || zoneSpec == JS::NewZoneInSystemZoneGroup) {
             MOZ_RELEASE_ASSERT(!rt->gc.systemZoneGroup);
             rt->gc.systemZoneGroup = group;
-            group->setUseExclusiveLocking();
         }
     }
 
     zoneHolder.forget();
     groupHolder.forget();
-    group->leave();
     return compartment.forget();
 }
 
@@ -7969,7 +7962,7 @@ GCRuntime::mergeCompartments(JSCompartment* source, JSCompartment* target)
     MOZ_ASSERT(source->zone()->compartments().length() == 1);
     MOZ_ASSERT(source->zone()->group()->zones().length() == 1);
 
-    JSContext* cx = rt->activeContextFromOwnThread();
+    JSContext* cx = rt->mainContextFromOwnThread();
 
     MOZ_ASSERT(!source->zone()->wasGCStarted());
     JS::AutoAssertNoGC nogc(cx);
@@ -8232,7 +8225,6 @@ js::ReleaseAllJITCode(FreeOp* fop)
 {
     js::CancelOffThreadIonCompile(fop->runtime());
 
-    JSRuntime::AutoProhibitActiveContextChange apacc(fop->runtime());
     for (ZonesIter zone(fop->runtime(), SkipAtoms); !zone.done(); zone.next()) {
         zone->setPreservingCode(false);
         zone->discardJitCode(fop);

js/src/gc/Nursery.cpp

@@ -747,7 +747,7 @@ js::Nursery::collect(JS::gcreason::Reason reason)
         for (auto& entry : tenureCounts.entries) {
             if (entry.count >= 3000) {
                 ObjectGroup* group = entry.group;
-                if (group->canPreTenure() && group->zone()->group()->canEnterWithoutYielding(cx)) {
+                if (group->canPreTenure()) {
                     AutoCompartment ac(cx, group);
                     group->setShouldPreTenure(cx);
                     pretenureCount++;
@@ -757,7 +757,6 @@ js::Nursery::collect(JS::gcreason::Reason reason)
     }
     for (ZonesIter zone(rt, SkipAtoms); !zone.done(); zone.next()) {
         if (shouldPretenure && zone->allocNurseryStrings && zone->tenuredStrings >= 30 * 1000) {
-            JSRuntime::AutoProhibitActiveContextChange apacc(rt);
             CancelOffThreadIonCompile(zone);
             bool preserving = zone->isPreservingCode();
             zone->setPreservingCode(false);

js/src/gc/RootMarking.cpp

@@ -80,9 +80,9 @@ JS::RootingContext::traceStackRoots(JSTracer* trc)
 }
 
 static void
-TraceExactStackRoots(const CooperatingContext& target, JSTracer* trc)
+TraceExactStackRoots(JSContext* cx, JSTracer* trc)
 {
-    target.context()->traceStackRoots(trc);
+    cx->traceStackRoots(trc);
 }
 
 template <typename T, TraceFunction<T> TraceFn = TraceNullableRoot>
@@ -196,16 +196,16 @@ AutoGCRooter::trace(JSTracer* trc)
 }
 
 /* static */ void
-AutoGCRooter::traceAll(const CooperatingContext& target, JSTracer* trc)
+AutoGCRooter::traceAll(JSContext* cx, JSTracer* trc)
 {
-    for (AutoGCRooter* gcr = target.context()->autoGCRooters_; gcr; gcr = gcr->down)
+    for (AutoGCRooter* gcr = cx->autoGCRooters_; gcr; gcr = gcr->down)
         gcr->trace(trc);
 }
 
 /* static */ void
-AutoGCRooter::traceAllWrappers(const CooperatingContext& target, JSTracer* trc)
+AutoGCRooter::traceAllWrappers(JSContext* cx, JSTracer* trc)
 {
-    for (AutoGCRooter* gcr = target.context()->autoGCRooters_; gcr; gcr = gcr->down) {
+    for (AutoGCRooter* gcr = cx->autoGCRooters_; gcr; gcr = gcr->down) {
         if (gcr->tag_ == WRAPVECTOR || gcr->tag_ == WRAPPER)
             gcr->trace(trc);
     }
@@ -319,18 +319,17 @@ js::gc::GCRuntime::traceRuntimeCommon(JSTracer* trc, TraceOrMarkRuntime traceOrM
     {
         gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::MARK_STACK);
 
-        JSContext* cx = TlsContext.get();
-        for (const CooperatingContext& target : rt->cooperatingContexts()) {
-            // Trace active interpreter and JIT stack roots.
-            TraceInterpreterActivations(cx, target, trc);
-            jit::TraceJitActivations(cx, target, trc);
+        JSContext* cx = rt->mainContextFromOwnThread();
 
-            // Trace legacy C stack roots.
-            AutoGCRooter::traceAll(target, trc);
+        // Trace active interpreter and JIT stack roots.
+        TraceInterpreterActivations(cx, trc);
+        jit::TraceJitActivations(cx, trc);
 
-            // Trace C stack roots.
-            TraceExactStackRoots(target, trc);
-        }
+        // Trace legacy C stack roots.
+        AutoGCRooter::traceAll(cx, trc);
+
+        // Trace C stack roots.
+        TraceExactStackRoots(cx, trc);
 
         for (RootRange r = rootsHash.ref().all(); !r.empty(); r.popFront()) {
             const RootEntry& entry = r.front();
@@ -347,9 +346,8 @@ js::gc::GCRuntime::traceRuntimeCommon(JSTracer* trc, TraceOrMarkRuntime traceOrM
     // Trace the shared Intl data.
     rt->traceSharedIntlData(trc);
 
-    // Trace anything in any of the cooperating threads.
-    for (const CooperatingContext& target : rt->cooperatingContexts())
-        target.context()->trace(trc);
+    // Trace the JSContext.
+    rt->mainContextFromOwnThread()->trace(trc);
 
     // Trace all compartment roots, but not the compartment itself; it is
     // traced via the parent pointer if traceRoots actually traces anything.

js/src/gc/Verifier.cpp

@@ -181,8 +181,7 @@ gc::GCRuntime::startVerifyPreBarriers()
 
     if (IsIncrementalGCUnsafe(rt) != AbortReason::None ||
         TlsContext.get()->keepAtoms ||
-        rt->hasHelperThreadZones() ||
-        rt->cooperatingContexts().length() != 1)
+        rt->hasHelperThreadZones())
     {
         return;
     }
@@ -334,7 +333,7 @@ gc::GCRuntime::endVerifyPreBarriers()
 
     MOZ_ASSERT(!JS::IsGenerationalGCEnabled(rt));
 
-    AutoPrepareForTracing prep(rt->activeContextFromOwnThread());
+    AutoPrepareForTracing prep(rt->mainContextFromOwnThread());
 
     bool compartmentCreated = false;
 

js/src/gc/ZoneGroup.cpp

@@ -17,8 +17,7 @@ namespace js {
 
 ZoneGroup::ZoneGroup(JSRuntime* runtime)
   : runtime(runtime),
-    ownerContext_(TlsContext.get()),
-    enterCount(1),
+    helperThreadOwnerContext_(nullptr),
     zones_(this),
     helperThreadUse(HelperThreadUse::None),
 #ifdef DEBUG
@@ -60,51 +59,18 @@ ZoneGroup::~ZoneGroup()
 }
 
 void
-ZoneGroup::enter(JSContext* cx)
+ZoneGroup::setHelperThreadOwnerContext(JSContext* cx)
 {
-    if (ownerContext().context() == cx) {
-        MOZ_ASSERT(enterCount);
-    } else {
-        if (useExclusiveLocking()) {
-            MOZ_ASSERT(!usedByHelperThread());
-            while (ownerContext().context() != nullptr) {
-                cx->yieldToEmbedding();
-            }
-        }
-        MOZ_RELEASE_ASSERT(ownerContext().context() == nullptr);
-        MOZ_ASSERT(enterCount == 0);
-        ownerContext_ = CooperatingContext(cx);
-        if (cx->generationalDisabled)
-            nursery().disable();
-
-        // Finish any Ion compilations in this zone group, in case compilation
-        // finished for some script in this group while no thread was in this
-        // group.
-        jit::AttachFinishedCompilations(this, nullptr);
-    }
-    enterCount++;
-}
-
-void
-ZoneGroup::leave()
-{
-    MOZ_ASSERT(ownedByCurrentThread());
-    MOZ_ASSERT(enterCount);
-    if (--enterCount == 0)
-        ownerContext_ = CooperatingContext(nullptr);
-}
-
-bool
-ZoneGroup::canEnterWithoutYielding(JSContext* cx)
-{
-    return ownerContext().context() == cx || ownerContext().context() == nullptr;
+    MOZ_ASSERT_IF(cx, TlsContext.get() == cx);
+    helperThreadOwnerContext_ = cx;
 }
 
 bool
-ZoneGroup::ownedByCurrentThread()
+ZoneGroup::ownedByCurrentHelperThread()
 {
+    MOZ_ASSERT(usedByHelperThread());
     MOZ_ASSERT(TlsContext.get());
-    return ownerContext().context() == TlsContext.get();
+    return helperThreadOwnerContext_ == TlsContext.get();
 }
 
 ZoneGroup::IonBuilderList&
@@ -156,26 +122,3 @@ ZoneGroup::deleteEmptyZone(Zone* zone)
 }
 
 } // namespace js
-
-JS::AutoRelinquishZoneGroups::AutoRelinquishZoneGroups(JSContext* cx)
-  : cx(cx)
-{
-    MOZ_ASSERT(cx == TlsContext.get());
-
-    AutoEnterOOMUnsafeRegion oomUnsafe;
-    for (ZoneGroupsIter group(cx->runtime()); !group.done(); group.next()) {
-        while (group->ownerContext().context() == cx) {
-            group->leave();
-            if (!enterList.append(group))
-                oomUnsafe.crash("AutoRelinquishZoneGroups");
-        }
-    }
-}
-
-JS::AutoRelinquishZoneGroups::~AutoRelinquishZoneGroups()
-{
-    for (size_t i = 0; i < enterList.length(); i++) {
-        ZoneGroup* group = static_cast<ZoneGroup*>(enterList[i]);
-        group->enter(cx);
-    }
-}

js/src/gc/ZoneGroup.h

@@ -33,24 +33,13 @@ class ZoneGroup
     JSRuntime* const runtime;
 
   private:
-    // The context with exclusive access to this zone group.
-    UnprotectedData<CooperatingContext> ownerContext_;
-
-    // The number of times the context has entered this zone group.
-    UnprotectedData<size_t> enterCount;
-
-    // If this flag is true, then we may need to block before entering this zone
-    // group. Blocking happens using JSContext::yieldToEmbedding.
-    UnprotectedData<bool> useExclusiveLocking_;
+    // The helper thread context with exclusive access to this zone group, if
+    // usedByHelperThread(), or nullptr when on the main thread.
+    UnprotectedData<JSContext*> helperThreadOwnerContext_;
 
   public:
-    CooperatingContext& ownerContext() { return ownerContext_.ref(); }
-    void* addressOfOwnerContext() { return &ownerContext_.ref().cx; }
-
-    void enter(JSContext* cx);
-    void leave();
-    bool canEnterWithoutYielding(JSContext* cx);
-    bool ownedByCurrentThread();
+    bool ownedByCurrentHelperThread();
+    void setHelperThreadOwnerContext(JSContext* cx);
 
     // All zones in the group.
   private:
@@ -101,10 +90,6 @@ class ZoneGroup
     inline bool isCollecting();
     inline bool isGCScheduled();
 
-    // See the useExclusiveLocking_ field above.
-    void setUseExclusiveLocking() { useExclusiveLocking_ = true; }
-    bool useExclusiveLocking() { return useExclusiveLocking_; }
-
     // Delete an empty zone after its contents have been merged.
     void deleteEmptyZone(Zone* zone);