220 lines
8.7 KiB
Text
220 lines
8.7 KiB
Text
/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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 "nsISupports.idl"
|
|
|
|
%{C++
|
|
#include "mozilla/Maybe.h"
|
|
#include "nsTArrayForwardDeclare.h"
|
|
#include "nsStringFwd.h"
|
|
#include "mozilla/MozPromise.h"
|
|
#include "mozilla/ipc/IPCCore.h"
|
|
%}
|
|
|
|
[ref] native nsCString(const nsCString);
|
|
[ref] native StringArrayRef(const nsTArray<nsCString>);
|
|
native ProfileDataBufferMozPromise(RefPtr<mozilla::MozPromise<FallibleTArray<uint8_t>, nsresult, true>>);
|
|
|
|
native ProfileFileDumpMozPromise(RefPtr<mozilla::MozPromise<mozilla::void_t, nsresult, true>>);
|
|
|
|
/**
|
|
* Start-up parameters for subprocesses are passed through nsIObserverService,
|
|
* which, unfortunately, means we need to implement nsISupports in order to
|
|
* go through it.
|
|
*/
|
|
[scriptable, builtinclass, uuid(0a175ba7-8fcf-4ce9-9c4b-ccc6272f4425)]
|
|
interface nsIProfilerStartParams : nsISupports
|
|
{
|
|
readonly attribute uint32_t entries;
|
|
readonly attribute double duration;
|
|
readonly attribute double interval;
|
|
readonly attribute uint32_t features;
|
|
readonly attribute uint64_t activeTabID;
|
|
|
|
[noscript, notxpcom, nostdcall] StringArrayRef getFilters();
|
|
};
|
|
|
|
[scriptable, builtinclass, uuid(ead3f75c-0e0e-4fbb-901c-1e5392ef5b2a)]
|
|
interface nsIProfiler : nsISupports
|
|
{
|
|
/*
|
|
* Control functions return as soon as this process' profiler has done its
|
|
* work. The returned promise gets resolved when sub-processes have completed
|
|
* their operation, or immediately if there are no sub-processes.
|
|
*/
|
|
[implicit_jscontext]
|
|
Promise StartProfiler(in uint32_t aEntries, in double aInterval,
|
|
in Array<AUTF8String> aFeatures,
|
|
[optional] in Array<AUTF8String> aFilters,
|
|
[optional] in uint64_t aActiveTabID,
|
|
[optional] in double aDuration);
|
|
[implicit_jscontext]
|
|
Promise StopProfiler();
|
|
boolean IsPaused();
|
|
[implicit_jscontext]
|
|
Promise Pause();
|
|
[implicit_jscontext]
|
|
Promise Resume();
|
|
boolean IsSamplingPaused();
|
|
[implicit_jscontext]
|
|
Promise PauseSampling();
|
|
[implicit_jscontext]
|
|
Promise ResumeSampling();
|
|
|
|
/*
|
|
* Resolves the returned promise after at least one full periodic sampling in
|
|
* each process.
|
|
* Rejects the promise if sampler is not running (yet, or anymore, or paused)
|
|
* in the parent process.
|
|
* This is mainly useful in tests, to wait just long enough to guarantee that
|
|
* at least one sample was taken in each process.
|
|
*/
|
|
[implicit_jscontext]
|
|
Promise waitOnePeriodicSampling();
|
|
|
|
/*
|
|
* Returns the JSON string of the profile. If aSinceTime is passed, only
|
|
* report samples taken at >= aSinceTime.
|
|
*/
|
|
string GetProfile([optional] in double aSinceTime);
|
|
|
|
/*
|
|
* Returns a JS object of the profile. If aSinceTime is passed, only report
|
|
* samples taken at >= aSinceTime.
|
|
*/
|
|
[implicit_jscontext]
|
|
jsval getProfileData([optional] in double aSinceTime);
|
|
|
|
[implicit_jscontext]
|
|
Promise getProfileDataAsync([optional] in double aSinceTime);
|
|
|
|
[implicit_jscontext]
|
|
Promise getProfileDataAsArrayBuffer([optional] in double aSinceTime);
|
|
|
|
[implicit_jscontext]
|
|
Promise getProfileDataAsGzippedArrayBuffer([optional] in double aSinceTime);
|
|
|
|
/**
|
|
* Asynchronously dump the profile collected so far to a file.
|
|
* Returns a promise that resolves once the file has been written, with data
|
|
* from all responsive IceCat processes. Note: This blocks the parent process
|
|
* while collecting its own data, then unblocks while child processes data is
|
|
* being collected.
|
|
* `aFilename` may be a full path, or a path relative to where IceCat was
|
|
* launched. The target directory must already exist.
|
|
*/
|
|
[implicit_jscontext]
|
|
Promise dumpProfileToFileAsync(in ACString aFilename,
|
|
[optional] in double aSinceTime);
|
|
|
|
|
|
/**
|
|
* Asynchronously dump the profile collected so far to a file. This is
|
|
* essentially the same as `dumpProfileToFileAsync`, but rather than returning
|
|
* a javascript Promise, it instead returns a MozPromise, meaning that we do
|
|
* not require a js context.
|
|
*/
|
|
[notxpcom, nostdcall] ProfileFileDumpMozPromise dumpProfileToFileAsyncNoJs(in ACString aFilename, in double aSinceTime);
|
|
|
|
/**
|
|
* Synchronously dump the profile collected so far in this process to a file.
|
|
* This profile will only contain data from the parent process, and from child
|
|
* processes that have ended during the session; other currently-live
|
|
* processes are ignored.
|
|
* `aFilename` may be a full path, or a path relative to where IceCat was
|
|
* launched. The target directory must already exist.
|
|
*/
|
|
void dumpProfileToFile(in string aFilename);
|
|
|
|
boolean IsActive();
|
|
|
|
/**
|
|
* Clear all registered and unregistered page information in prifiler.
|
|
*/
|
|
void ClearAllPages();
|
|
|
|
/**
|
|
* Returns an array of the features that are supported in this build.
|
|
* Features may vary depending on platform and build flags.
|
|
*/
|
|
Array<AUTF8String> GetFeatures();
|
|
|
|
/**
|
|
* Returns a JavaScript object that contains a description of the currently configured
|
|
* state of the profiler when the profiler is active. This can be useful to assert
|
|
* the UI of the profiler's recording panel in tests. It returns null when the profiler
|
|
* is not active.
|
|
*/
|
|
[implicit_jscontext]
|
|
readonly attribute jsval activeConfiguration;
|
|
|
|
/**
|
|
* Returns an array of all features that are supported by the profiler.
|
|
* The array may contain features that are not supported in this build.
|
|
*/
|
|
Array<AUTF8String> GetAllFeatures();
|
|
|
|
void GetBufferInfo(out uint32_t aCurrentPosition, out uint32_t aTotalSize,
|
|
out uint32_t aGeneration);
|
|
|
|
/**
|
|
* Returns the elapsed time, in milliseconds, since the profiler's epoch.
|
|
* The epoch is guaranteed to be constant for the duration of the
|
|
* process, but is otherwise arbitrary.
|
|
*/
|
|
double getElapsedTime();
|
|
|
|
/**
|
|
* Contains an array of shared library objects.
|
|
* Every object has the properties:
|
|
* - start: The start address of the memory region occupied by this library.
|
|
* - end: The end address of the memory region occupied by this library.
|
|
* - offset: Usually zero, except on Linux / Android if the first mapped
|
|
* section of the library has been mapped to an address that's
|
|
* different from the library's base address.
|
|
* Then offset = start - baseAddress.
|
|
* - name: The name (file basename) of the binary.
|
|
* - path: The full absolute path to the binary.
|
|
* - debugName: On Windows, the name of the pdb file for the binary. On other
|
|
* platforms, the same as |name|.
|
|
* - debugPath: On Windows, the full absolute path of the pdb file for the
|
|
* binary. On other platforms, the same as |path|.
|
|
* - arch: On Mac, the name of the architecture that identifies the right
|
|
* binary image of a fat binary. Example values are "i386", "x86_64",
|
|
* and "x86_64h". (x86_64h is used for binaries that contain
|
|
* instructions that are specific to the Intel Haswell microarchitecture.)
|
|
* On non-Mac platforms, arch is "".
|
|
* - breakpadId: A unique identifier string for this library, as used by breakpad.
|
|
*/
|
|
[implicit_jscontext]
|
|
readonly attribute jsval sharedLibraries;
|
|
|
|
/**
|
|
* Returns a promise that resolves to a SymbolTableAsTuple for the binary at
|
|
* the given path.
|
|
*
|
|
* SymbolTable as tuple: [addrs, index, buffer]
|
|
* Contains a symbol table, which can be used to map addresses to strings.
|
|
*
|
|
* The first element of this tuple, commonly named "addrs", is a sorted array of
|
|
* symbol addresses, as library-relative offsets in bytes, in ascending order.
|
|
* The third element of this tuple, commonly named "buffer", is a buffer of
|
|
* bytes that contains all strings from this symbol table, in the order of the
|
|
* addresses they correspond to, in utf-8 encoded form, all concatenated
|
|
* together.
|
|
* The second element of this tuple, commonly named "index", contains positions
|
|
* into "buffer". For every address, that position is where the string for that
|
|
* address starts in the buffer.
|
|
* index.length == addrs.length + 1.
|
|
* index[addrs.length] is the end position of the last string in the buffer.
|
|
*
|
|
* The string for the address addrs[i] is
|
|
* (new TextDecoder()).decode(buffer.subarray(index[i], index[i + 1]))
|
|
*/
|
|
[implicit_jscontext]
|
|
Promise getSymbolTable(in ACString aDebugPath, in ACString aBreakpadID);
|
|
|
|
[notxpcom, nostdcall] ProfileDataBufferMozPromise getProfileDataAsGzippedArrayBufferAndroid(in double aSinceTime);
|
|
};
|