Quelle memory.js Sprache: JAVA

/* 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 {
  reportException,
} = require("resource://devtools/shared/DevToolsUtils.js");
const { expectState } = require("resource://devtools/server/actors/common.js");

loader.lazyRequireGetter(
  this,
  "EventEmitter",
  "resource://devtools/shared/event-emitter.js"
);
const lazy = {};
ChromeUtils.defineESModuleGetters(
  lazy,
  {
    DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs",
  },
  { global: "contextual" }
);
loader.lazyRequireGetter(
  this,
  "StackFrameCache",
  "resource://devtools/server/actors/utils/stack.js",
  true
);
loader.lazyRequireGetter(
  this,
  "ParentProcessTargetActor",
  "resource://devtools/server/actors/targets/parent-process.js",
  true
);
loader.lazyRequireGetter(
  this,
  "ContentProcessTargetActor",
  "resource://devtools/server/actors/targets/content-process.js",
  true
);

/**
* A class that returns memory data for a parent actor's window.
* Using a target-scoped actor with this instance will measure the memory footprint of its
* parent tab. Using a global-scoped actor instance however, will measure the memory
* footprint of the chrome window referenced by its root actor.
*
* To be consumed by actor's, like MemoryActor using this module to
* send information over RDP, and TimelineActor for using more light-weight
* utilities like GC events and measuring memory consumption.
*/
function Memory(parent, frameCache = new StackFrameCache()) {
  EventEmitter.decorate(this);

  this.parent = parent;
  this._mgr = Cc["@mozilla.org/memory-reporter-manager;1"].getService(
    Ci.nsIMemoryReporterManager
  );
  this.state = "detached";
  this._dbg = null;
  this._frameCache = frameCache;

  this._onGarbageCollection = this._onGarbageCollection.bind(this);
  this._emitAllocations = this._emitAllocations.bind(this);
  this._onWindowReady = this._onWindowReady.bind(this);

  EventEmitter.on(this.parent, "window-ready", this._onWindowReady);
}

Memory.prototype = {
  destroy() {
    EventEmitter.off(this.parent, "window-ready", this._onWindowReady);

    this._mgr = null;
    if (this.state === "attached") {
      this.detach();
    }
  },

  get dbg() {
    if (!this._dbg) {
      this._dbg = this.parent.makeDebugger();
    }
    return this._dbg;
  },

  /**
   * Attach to this MemoryBridge.
   *
   * This attaches the MemoryBridge's Debugger instance so that you can start
   * recording allocations or take a census of the heap. In addition, the
   * MemoryBridge will start emitting GC events.
   */
  attach() {
    // The actor may be attached by the Target via recordAllocation configuration
    // or manually by the frontend.
    if (this.state == "attached") {
      return this.state;
    }
    this.dbg.addDebuggees();
    this.dbg.memory.onGarbageCollection = this._onGarbageCollection.bind(this);
    this.state = "attached";
    return this.state;
  },

  /**
   * Detach from this MemoryBridge.
   */
  detach: expectState(
    "attached",
    function () {
      this._clearDebuggees();
      this.dbg.disable();
      this._dbg = null;
      this.state = "detached";
      return this.state;
    },
    "detaching from the debugger"
  ),

  /**
   * Gets the current MemoryBridge attach/detach state.
   */
  getState() {
    return this.state;
  },

  _clearDebuggees() {
    if (this._dbg) {
      if (this.isRecordingAllocations()) {
        this.dbg.memory.drainAllocationsLog();
      }
      this._clearFrames();
      this.dbg.removeAllDebuggees();
    }
  },

  _clearFrames() {
    if (this.isRecordingAllocations()) {
      this._frameCache.clearFrames();
    }
  },

  /**
   * Handler for the parent actor's "window-ready" event.
   */
  _onWindowReady({ isTopLevel }) {
    if (this.state == "attached") {
      this._clearDebuggees();
      if (isTopLevel && this.isRecordingAllocations()) {
        this._frameCache.initFrames();
      }
      this.dbg.addDebuggees();
    }
  },

  /**
   * Returns a boolean indicating whether or not allocation
   * sites are being tracked.
   */
  isRecordingAllocations() {
    return this.dbg.memory.trackingAllocationSites;
  },

  /**
   * Save a heap snapshot scoped to the current debuggees' portion of the heap
   * graph.
   *
   * @param {Object|null} boundaries
   *
   * @returns {String} The snapshot id.
   */
  saveHeapSnapshot: expectState(
    "attached",
    function (boundaries = null) {
      // If we are observing the whole process, then scope the snapshot
      // accordingly. Otherwise, use the debugger's debuggees.
      if (!boundaries) {
        if (
          this.parent instanceof ParentProcessTargetActor ||
          this.parent instanceof ContentProcessTargetActor
        ) {
          boundaries = { runtime: true };
        } else {
          boundaries = { debugger: this.dbg };
        }
      }
      return ChromeUtils.saveHeapSnapshotGetId(boundaries);
    },
    "saveHeapSnapshot"
  ),

  /**
   * Take a census of the heap. See js/src/doc/Debugger/Debugger.Memory.md for
   * more information.
   */
  takeCensus: expectState(
    "attached",
    function () {
      return this.dbg.memory.takeCensus();
    },
    "taking census"
  ),

  /**
   * Start recording allocation sites.
   *
   * @param {number} options.probability
   *                 The probability we sample any given allocation when recording
   *                 allocations. Must be between 0 and 1 -- defaults to 1.
   * @param {number} options.maxLogLength
   *                 The maximum number of allocation events to keep in the
   *                 log. If new allocs occur while at capacity, oldest
   *                 allocations are lost. Must fit in a 32 bit signed integer.
   * @param {number} options.drainAllocationsTimeout
   *                 A number in milliseconds of how often, at least, an `allocation`
   *                 event gets emitted (and drained), and also emits and drains on every
   *                 GC event, resetting the timer.
   */
  startRecordingAllocations: expectState(
    "attached",
    function (options = {}) {
      if (this.isRecordingAllocations()) {
        return this._getCurrentTime();
      }

      this._frameCache.initFrames();

      this.dbg.memory.allocationSamplingProbability =
        options.probability != null ? options.probability : 1.0;

      this.drainAllocationsTimeoutTimer = options.drainAllocationsTimeout;

      if (this.drainAllocationsTimeoutTimer != null) {
        if (this._poller) {
          this._poller.disarm();
        }
        this._poller = new lazy.DeferredTask(
          this._emitAllocations,
          this.drainAllocationsTimeoutTimer,
          0
        );
        this._poller.arm();
      }

      if (options.maxLogLength != null) {
        this.dbg.memory.maxAllocationsLogLength = options.maxLogLength;
      }
      this.dbg.memory.trackingAllocationSites = true;

      return this._getCurrentTime();
    },
    "starting recording allocations"
  ),

  /**
   * Stop recording allocation sites.
   */
  stopRecordingAllocations: expectState(
    "attached",
    function () {
      if (!this.isRecordingAllocations()) {
        return this._getCurrentTime();
      }
      this.dbg.memory.trackingAllocationSites = false;
      this._clearFrames();

      if (this._poller) {
        this._poller.disarm();
        this._poller = null;
      }

      return this._getCurrentTime();
    },
    "stopping recording allocations"
  ),

  /**
   * Return settings used in `startRecordingAllocations` for `probability`
   * and `maxLogLength`. Currently only uses in tests.
   */
  getAllocationsSettings: expectState(
    "attached",
    function () {
      return {
        maxLogLength: this.dbg.memory.maxAllocationsLogLength,
        probability: this.dbg.memory.allocationSamplingProbability,
      };
    },
    "getting allocations settings"
  ),

  /**
   * Get a list of the most recent allocations since the last time we got
   * allocations, as well as a summary of all allocations since we've been
   * recording.
   *
   * @returns Object
   *          An object of the form:
   *
   *            {
   *              allocations: [<index into "frames" below>, ...],
   *              allocationsTimestamps: [
   *                <timestamp for allocations[0]>,
   *                <timestamp for allocations[1]>,
   *                ...
   *              ],
   *              allocationSizes: [
   *                <bytesize for allocations[0]>,
   *                <bytesize for allocations[1]>,
   *                ...
   *              ],
   *              frames: [
   *                {
   *                  line: <line number for this frame>,
   *                  column: <column number for this frame>,
   *                  source: <filename string for this frame>,
   *                  functionDisplayName:
   *                    <this frame's inferred function name function or null>,
   *                  parent: <index into "frames">
   *                },
   *                ...
   *              ],
   *            }
   *
   *          The timestamps' unit is microseconds since the epoch.
   *
   *          Subsequent `getAllocations` request within the same recording and
   *          tab navigation will always place the same stack frames at the same
   *          indices as previous `getAllocations` requests in the same
   *          recording. In other words, it is safe to use the index as a
   *          unique, persistent id for its frame.
   *
   *          Additionally, the root node (null) is always at index 0.
   *
   *          We use the indices into the "frames" array to avoid repeating the
   *          description of duplicate stack frames both when listing
   *          allocations, and when many stacks share the same tail of older
   *          frames. There shouldn't be any duplicates in the "frames" array,
   *          as that would defeat the purpose of this compression trick.
   *
   *          In the future, we might want to split out a frame's "source" and
   *          "functionDisplayName" properties out the same way we have split
   *          frames out with the "frames" array. While this would further
   *          compress the size of the response packet, it would increase CPU
   *          usage to build the packet, and it should, of course, be guided by
   *          profiling and done only when necessary.
   */
  getAllocations: expectState(
    "attached",
    function () {
      if (this.dbg.memory.allocationsLogOverflowed) {
        // Since the last time we drained the allocations log, there have been
        // more allocations than the log's capacity, and we lost some data. There
        // isn't anything actionable we can do about this, but put a message in
        // the browser console so we at least know that it occurred.
        reportException(
          "MemoryBridge.prototype.getAllocations",
          "Warning: allocations log overflowed and lost some data."
        );
      }

      const allocations = this.dbg.memory.drainAllocationsLog();
      const packet = {
        allocations: [],
        allocationsTimestamps: [],
        allocationSizes: [],
      };
      for (const { frame: stack, timestamp, size } of allocations) {
        if (stack && Cu.isDeadWrapper(stack)) {
          continue;
        }

        // Safe because SavedFrames are frozen/immutable.
        const waived = Cu.waiveXrays(stack);

        // Ensure that we have a form, size, and index for new allocations
        // because we potentially haven't seen some or all of them yet. After this
        // loop, we can rely on the fact that every frame we deal with already has
        // its metadata stored.
        const index = this._frameCache.addFrame(waived);

        packet.allocations.push(index);
        packet.allocationsTimestamps.push(timestamp);
        packet.allocationSizes.push(size);
      }

      return this._frameCache.updateFramePacket(packet);
    },
    "getting allocations"
  ),

  /*
   * Force a browser-wide GC.
   */
  forceGarbageCollection() {
    for (let i = 0; i < 3; i++) {
      Cu.forceGC();
    }
  },

  /**
   * Force an XPCOM cycle collection. For more information on XPCOM cycle
   * collection, see
   * https://developer.mozilla.org/en-US/docs/Interfacing_with_the_XPCOM_cycle_collector#What_the_cycle_collector_does
   */
  forceCycleCollection() {
    Cu.forceCC();
  },

  /**
   * A method that returns a detailed breakdown of the memory consumption of the
   * associated window.
   *
   * @returns object
   */
  measure() {
    const result = {};

    const jsObjectsSize = {};
    const jsStringsSize = {};
    const jsOtherSize = {};
    const domSize = {};
    const styleSize = {};
    const otherSize = {};
    const totalSize = {};
    const jsMilliseconds = {};
    const nonJSMilliseconds = {};

    try {
      this._mgr.sizeOfTab(
        this.parent.window,
        jsObjectsSize,
        jsStringsSize,
        jsOtherSize,
        domSize,
        styleSize,
        otherSize,
        totalSize,
        jsMilliseconds,
        nonJSMilliseconds
      );
      result.total = totalSize.value;
      result.domSize = domSize.value;
      result.styleSize = styleSize.value;
      result.jsObjectsSize = jsObjectsSize.value;
      result.jsStringsSize = jsStringsSize.value;
      result.jsOtherSize = jsOtherSize.value;
      result.otherSize = otherSize.value;
      result.jsMilliseconds = jsMilliseconds.value.toFixed(1);
      result.nonJSMilliseconds = nonJSMilliseconds.value.toFixed(1);
    } catch (e) {
      reportException("MemoryBridge.prototype.measure", e);
    }

    return result;
  },

  residentUnique() {
    return this._mgr.residentUnique;
  },

  /**
   * Handler for GC events on the Debugger.Memory instance.
   */
  _onGarbageCollection(data) {
    this.emit("garbage-collection", data);

    // If `drainAllocationsTimeout` set, fire an allocations event with the drained log,
    // which will restart the timer.
    if (this._poller) {
      this._poller.disarm();
      this._emitAllocations();
    }
  },

  /**
   * Called on `drainAllocationsTimeoutTimer` interval if and only if set
   * during `startRecordingAllocations`, or on a garbage collection event if
   * drainAllocationsTimeout was set.
   * Drains allocation log and emits as an event and restarts the timer.
   */
  _emitAllocations() {
    this.emit("allocations", this.getAllocations());
    this._poller.arm();
  },

  /**
   * Accesses the docshell to return the current process time.
   */
  _getCurrentTime() {
    const docShell = this.parent.isRootActor
      ? this.parent.docShell
      : this.parent.originalDocShell;
    if (docShell) {
      return docShell.now();
    }
    // When used from the ContentProcessTargetActor, parent has no docShell,
    // so fallback to Cu.now
    return Cu.now();
  },
};

exports.Memory = Memory;

quality98%

¤ Dauer der Verarbeitung: 0.27 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.