tor-browser

browser_gc_schedule.js (10781B)

---

/* 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/. */

"use strict";

const TEST_PAGE =
 "http://mochi.test:8888/browser/dom/ipc/tests/file_dummy.html";

async function waitForGCBegin() {
 var waitTopic = "garbage-collector-begin";
 var observer = {};

 info("Waiting for " + waitTopic);
 // This fixes a ReferenceError for Date, it's weird.
 ok(Date.now(), "Date.now()");
 var when = await new Promise(resolve => {
   observer.observe = function () {
     resolve(Date.now());
   };

   Services.obs.addObserver(observer, waitTopic);
 });

 Services.obs.removeObserver(observer, waitTopic);

 // This delay attempts to make the time stamps unique.
 do {
   var now = Date.now();
 } while (when + 5 > now);

 return when;
}

async function waitForGCEnd() {
 var waitTopic = "garbage-collector-end";
 var observer = {};

 info("Waiting for " + waitTopic);
 // This fixes a ReferenceError for Date, it's weird.
 ok(Date.now(), "Date.now()");
 let when = await new Promise(resolve => {
   observer.observe = function () {
     resolve(Date.now());
   };

   Services.obs.addObserver(observer, waitTopic);
 });

 Services.obs.removeObserver(observer, waitTopic);

 do {
   var now = Date.now();
 } while (when + 5 > now);

 return when;
}

function getProcessID() {
 return Services.appinfo.processID;
}

async function resolveInOrder(promisesAndStates) {
 var order = [];
 var promises = [];

 for (let p of promisesAndStates) {
   promises.push(
     p.promise.then(when => {
       info(`Tab: ${p.tab} did ${p.state}`);
       order.push({ tab: p.tab, state: p.state, when });
     })
   );
 }

 await Promise.all(promises);

 return order;
}

// Check that the list of events returned by resolveInOrder are in a
// sensible order.
function checkOneAtATime(events) {
 var cur = null;
 var lastWhen = null;

 info("Checking order of events");
 for (const e of events) {
   ok(e.state === "begin" || e.state === "end", "event.state is good");
   Assert.notStrictEqual(e.tab, undefined, "event.tab exists");

   if (lastWhen) {
     // We need these in sorted order so that the other checks here make
     // sense.
     Assert.lessOrEqual(
       lastWhen,
       e.when,
       `Unsorted events, last: ${lastWhen}, this: ${e.when}`
     );
   }
   lastWhen = e.when;

   if (e.state === "begin") {
     is(cur, null, `GC can begin on tab ${e.tab}`);
     cur = e.tab;
   } else {
     is(e.tab, cur, `GC can end on tab ${e.tab}`);
     cur = null;
   }
 }

 is(cur, null, "No GC left running");
}

function checkAllCompleted(events, expectTabsCompleted) {
 var tabsCompleted = events.filter(e => e.state === "end").map(e => e.tab);

 for (var t of expectTabsCompleted) {
   ok(tabsCompleted.includes(t), `Tab ${t} did a GC`);
 }
}

async function setupTabsAndOneForForeground(num_tabs) {
 ++num_tabs;
 var pids = [];

 const parent_pid = getProcessID();
 info("Parent process PID is " + parent_pid);

 const tabs = await Promise.all(
   Array(num_tabs)
     .fill()
     .map(_ => {
       return BrowserTestUtils.openNewForegroundTab({
         gBrowser,
         opening: TEST_PAGE,
         forceNewProcess: true,
       });
     })
 );

 for (const [i, tab] of Object.entries(tabs)) {
   const tab_pid = await SpecialPowers.spawn(
     tab.linkedBrowser,
     [],
     getProcessID
   );

   info(`Tab ${i} pid is ${tab_pid}`);
   isnot(parent_pid, tab_pid, `Tab ${i} is in content process`);
   ok(!pids.includes(tab_pid), `Tab ${i} is in a distinct process`);

   pids.push(tab_pid);
 }

 // Since calling openNewForegroundTab several times in a row doesn't update
 // process priorities correctly, we need to explicitly switch tabs.
 for (let tab of tabs) {
   await BrowserTestUtils.switchTab(gBrowser, tab);
 }

 return tabs;
}

function doContentRunNextCollectionTimer() {
 content.windowUtils.pokeGC("PAGE_HIDE");
 content.windowUtils.runNextCollectorTimer("PAGE_HIDE");
}

function startNextCollection(
 tab,
 tab_num,
 waits,
 fn = doContentRunNextCollectionTimer
) {
 var browser = tab.linkedBrowser;

 // Finish any currently running GC.
 SpecialPowers.spawn(browser, [], () => {
   SpecialPowers.Cu.getJSTestingFunctions().finishgc();
 });

 if (tab.selected) {
   // One isn't expected to use the return value with foreground tab!
   return {};
 }

 var waitBegin = SpecialPowers.spawn(browser, [], waitForGCBegin);
 var waitEnd = SpecialPowers.spawn(browser, [], waitForGCEnd);
 waits.push({ promise: waitBegin, tab: tab_num, state: "begin" });
 waits.push({ promise: waitEnd, tab: tab_num, state: "end" });

 SpecialPowers.spawn(browser, [], fn);

 // Return these so that the abort GC test can wait for the begin.
 return { waitBegin, waitEnd };
}

add_task(async function gcOneAtATime() {
 SpecialPowers.pushPrefEnv({
   set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
 });

 const num_tabs = 12;
 var tabs = await setupTabsAndOneForForeground(num_tabs);

 info("Tabs ready, Asking for GCs");
 var waits = [];
 for (var i = 0; i < num_tabs; i++) {
   startNextCollection(tabs[i], i, waits);
 }

 let order = await resolveInOrder(waits);
 // We need these in the order they actually occurred, so far that's how
 // they're returned, but we'll sort them to be sure.
 order.sort((e1, e2) => e1.when - e2.when);
 checkOneAtATime(order);
 checkAllCompleted(
   order,
   Array.from({ length: num_tabs }, (_, n) => n)
 );

 for (var tab of tabs) {
   BrowserTestUtils.removeTab(tab);
 }

 SpecialPowers.popPrefEnv();
});

add_task(async function gcAbort() {
 SpecialPowers.pushPrefEnv({
   set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
 });

 const num_tabs = 2;
 var tabs = await setupTabsAndOneForForeground(num_tabs);

 info("Tabs ready, Asking for GCs");
 var waits = [];

 var tab0Waits = startNextCollection(tabs[0], 0, waits, () => {
   SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
 });
 await tab0Waits.waitBegin;

 // Tab 0 has started a GC. Now we schedule a GC in tab one.  It must not
 // begin yet (but we don't check that, gcOneAtATime is assumed to check
 // this.
 startNextCollection(tabs[1], 1, waits);

 // Request that tab 0 abort, this test checks that tab 1 can now begin.
 SpecialPowers.spawn(tabs[0].linkedBrowser, [], () => {
   SpecialPowers.Cu.getJSTestingFunctions().abortgc();
 });

 let order = await resolveInOrder(waits);
 // We need these in the order they actually occurred, so far that's how
 // they're returned, but we'll sort them to be sure.
 order.sort((e1, e2) => e1.when - e2.when);
 checkOneAtATime(order);
 checkAllCompleted(
   order,
   Array.from({ length: num_tabs }, (_, n) => n)
 );

 for (var tab of tabs) {
   BrowserTestUtils.removeTab(tab);
 }

 SpecialPowers.popPrefEnv();
});

add_task(async function gcJSInitiatedDuring() {
 SpecialPowers.pushPrefEnv({
   set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
 });

 const num_tabs = 3;
 var tabs = await setupTabsAndOneForForeground(num_tabs);

 let completed;
 let retry = 0;
 const maxRetries = 3;
 do {
   completed = true;
   retry++;

   info("Tabs ready, Asking for GCs");
   var waits = [];

   // Start a GC on tab 0 to consume the scheduler's "token".
   var tab0Waits = startNextCollection(tabs[0], 0, waits, () => {
     SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
   });
   await tab0Waits.waitBegin;
   info("GC on tab 0 has begun");

   // Request a GC in tab 1, this will be blocked by the ongoing GC in tab 0.
   var tab1Waits = startNextCollection(tabs[1], 1, waits);

   // Force a GC to start in tab 1.  This won't wait for tab 0.
   SpecialPowers.spawn(tabs[1].linkedBrowser, [], () => {
     SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
   });

   await tab1Waits.waitBegin;
   info("GC on tab 1 has begun");

   // The GC in tab 0 should still be running.
   var state = await SpecialPowers.spawn(tabs[0].linkedBrowser, [], () => {
     return SpecialPowers.Cu.getJSTestingFunctions().gcstate();
   });

   info("State of Tab 0 GC is " + state);
   if (state == "NotActive") {
     // The GC finished earlier than expected. The test must be retried.
     info("GC finished in tab 0");
     completed = false;
   }

   // Let the GCs complete, verify that a GC in a 3rd tab can acquire a token.
   startNextCollection(tabs[2], 2, waits);

   let order = await resolveInOrder(waits);
   info("All GCs finished");
   checkAllCompleted(
     order,
     Array.from({ length: num_tabs }, (_, n) => n)
   );
 } while (!completed && retry <= maxRetries);

 ok(completed, "GC in tab 0 finished sooner than expected");

 for (var tab of tabs) {
   BrowserTestUtils.removeTab(tab);
 }

 SpecialPowers.popPrefEnv();
});

add_task(async function gcJSInitiatedBefore() {
 SpecialPowers.pushPrefEnv({
   set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
 });

 const num_tabs = 8;
 var tabs = await setupTabsAndOneForForeground(num_tabs);

 let completed;
 let retry = 0;
 const maxRetries = 3;
 do {
   completed = true;
   retry++;

   info("Tabs ready");
   var waits = [];

   // Start a GC on tab 0 to consume the scheduler's first "token".
   info("Force a JS-initiated GC in tab 0");
   var tab0Waits = startNextCollection(tabs[0], 0, waits, () => {
     SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
   });
   await tab0Waits.waitBegin;

   info("Request GCs in remaining tabs");
   for (var i = 1; i < num_tabs; i++) {
     startNextCollection(tabs[i], i, waits);
   }

   // The GC in tab 0 should still be running.
   var state = await SpecialPowers.spawn(tabs[0].linkedBrowser, [], () => {
     return SpecialPowers.Cu.getJSTestingFunctions().gcstate();
   });

   info("State is " + state);
   if (state == "NotActive") {
     // The GC finished earlier than expected. The test must be retried.
     info("GC finished in tab 0");
     completed = false;
   }

   let order = await resolveInOrder(waits);
   // We need these in the order they actually occurred, so far that's how
   // they're returned, but we'll sort them to be sure.
   order.sort((e1, e2) => e1.when - e2.when);
   checkOneAtATime(order);
   checkAllCompleted(
     order,
     Array.from({ length: num_tabs }, (_, n) => n)
   );
 } while (!completed && retry <= maxRetries);

 ok(completed, "GC in tab 0 finished sooner than expected");

 for (var tab of tabs) {
   BrowserTestUtils.removeTab(tab);
 }

 SpecialPowers.popPrefEnv();
});