No bug, DONTBUILD. Comment fix.
authorSteve Fink <sfink@mozilla.com>
Sat, 27 Apr 2013 12:27:53 -0700
changeset 141101 e9fd6706b679d99d802d169ea0aa0fd89f161b75
parent 141100 d95d80a1580b3e2836e0d64f6d8e6b696e4828bc
child 141102 791332cb80a723f8a9e01d43bc11b2390a8d1d7e
push id2579
push userakeybl@mozilla.com
push dateMon, 24 Jun 2013 18:52:47 +0000
treeherdermozilla-beta@b69b7de8a05a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone23.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
No bug, DONTBUILD. Comment fix.
js/public/RootingAPI.h
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -18,17 +18,17 @@
 /*
  * Moving GC Stack Rooting
  *
  * A moving GC may change the physical location of GC allocated things, even
  * when they are rooted, updating all pointers to the thing to refer to its new
  * location. The GC must therefore know about all live pointers to a thing,
  * not just one of them, in order to behave correctly.
  *
- * The |Root| and |Handle| classes below are used to root stack locations
+ * The |Rooted| and |Handle| classes below are used to root stack locations
  * whose value may be held live across a call that can trigger GC. For a
  * code fragment such as:
  *
  * JSObject *obj = NewObject(cx);
  * DoSomething(cx);
  * ... = obj->lastProperty();
  *
  * If |DoSomething()| can trigger a GC, the stack location of |obj| must be
@@ -68,42 +68,37 @@
  *   generated, which is quicker and easier to fix than when relying on a
  *   separate rooting analysis.
  *
  * - MutableHandle<T> is a non-const reference to Rooted<T>. It is used in the
  *   same way as Handle<T> and includes a |set(const T &v)| method to allow
  *   updating the value of the referenced Rooted<T>. A MutableHandle<T> can be
  *   created from a Rooted<T> by using |Rooted<T>::operator&()|.
  *
- * In some cases the small performance overhead of exact rooting is too much.
- * In these cases, try the following:
+ * In some cases the small performance overhead of exact rooting (measured to
+ * be a few nanoseconds on desktop) is too much. In these cases, try the
+ * following:
  *
  * - Move all Rooted<T> above inner loops: this allows you to re-use the root
  *   on each iteration of the loop.
  *
  * - Pass Handle<T> through your hot call stack to avoid re-rooting costs at
  *   every invocation.
  *
- * There also exists a set of RawT typedefs for modules without rooting
- * concerns, such as the GC. Do not use these as they provide no rooting
- * protection whatsoever.
- *
  * The following diagram explains the list of supported, implicit type
  * conversions between classes of this family:
  *
  *  Rooted<T> ----> Handle<T>
  *     |               ^
  *     |               |
  *     |               |
  *     +---> MutableHandle<T>
  *     (via &)
  *
- * Currently, all of these types have an implicit conversion to RawT. These are
- * present only for the purpose of bootstrapping exact rooting and will be
- * removed in the future (Bug 817164).
+ * All of these types have an implicit conversion to raw pointers.
  */
 
 namespace js {
 
 class Module;
 
 template <typename T>
 struct RootMethods {};