The Tor Browser: js/src/vm/ForkJoin.h@129ffea94266 (annotated)

js/src/vm/ForkJoin.h@129ffea94266 (annotated)

js/src/vm/ForkJoin.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * 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/. */
 #ifndef vm_ForkJoin_h
 #define vm_ForkJoin_h
 #include "mozilla/ThreadLocal.h"
 #include "jscntxt.h"
 #include "gc/GCInternals.h"
 #include "jit/Ion.h"
 ///////////////////////////////////////////////////////////////////////////
 // Read Me First
 //
 // The ForkJoin abstraction:
 // -------------------------
 //
 // This is the building block for executing multi-threaded JavaScript with
 // shared memory (as distinct from Web Workers).  The idea is that you have
 // some (typically data-parallel) operation which you wish to execute in
 // parallel across as many threads as you have available.
 //
 // The ForkJoin abstraction is intended to be used by self-hosted code
 // to enable parallel execution.  At the top-level, it consists of a native
 // function (exposed as the ForkJoin intrinsic) that is used like so:
 //
 //     ForkJoin(func, sliceStart, sliceEnd, mode)
 //
 // The intention of this statement is to start some some number (usually the
 // number of hardware threads) of copies of |func()| running in parallel. Each
 // copy will then do a portion of the total work, depending on
 // workstealing-based load balancing.
 //
 // Typically, each of the N slices runs in a different worker thread, but that
 // is not something you should rely upon---if work-stealing is enabled it
 // could be that a single worker thread winds up handling multiple slices.
 //
 // The second and third arguments, |sliceStart| and |sliceEnd|, are the slice
 // boundaries. These numbers must each fit inside an uint16_t.
 //
 // The fourth argument, |mode|, is an internal mode integer giving finer
 // control over the behavior of ForkJoin. See the |ForkJoinMode| enum.
 //
 // func() should expect the following arguments:
 //
 //     func(workerId, sliceStart, sliceEnd)
 //
 // The |workerId| parameter is the id of the worker executing the function. It
 // is 0 in sequential mode.
 //
 // The |sliceStart| and |sliceEnd| parameters are the current bounds that that
 // the worker is handling. In parallel execution, these parameters are not
 // used. In sequential execution, they tell the worker what slices should be
 // processed. During the warm up phase, sliceEnd == sliceStart + 1.
 //
 // |func| can keep asking for more work from the scheduler by calling the
 // intrinsic |GetForkJoinSlice(sliceStart, sliceEnd, id)|. When there are no
 // more slices to hand out, ThreadPool::MAX_SLICE_ID is returned as a sentinel
 // value. By exposing this function as an intrinsic, we reduce the number of
 // JS-C++ boundary crossings incurred by workstealing, which may have many
 // slices.
 //
 // In sequential execution, |func| should return the maximum computed slice id
 // S for which all slices with id < S have already been processed. This is so
 // ThreadPool can track the leftmost completed slice id to maintain
 // determinism. Slices which have been completed in sequential execution
 // cannot be re-run in parallel execution.
 //
 // In parallel execution, |func| MUST PROCESS ALL SLICES BEFORE RETURNING!
 // Not doing so is an error and is protected by debug asserts in ThreadPool.
 //
 // Warmups and Sequential Fallbacks
 // --------------------------------
 //
 // ForkJoin can only execute code in parallel when it has been
 // ion-compiled in Parallel Execution Mode. ForkJoin handles this part
 // for you. However, because ion relies on having decent type
 // information available, it is necessary to run the code sequentially
 // for a few iterations first to get the various type sets "primed"
 // with reasonable information.  We try to make do with just a few
 // runs, under the hypothesis that parallel execution code which reach
 // type stability relatively quickly.
 //
 // The general strategy of ForkJoin is as follows:
 //
 // - If the code has not yet been run, invoke `func` sequentially with
 //   warmup set to true.  When warmup is true, `func` should try and
 //   do less work than normal---just enough to prime type sets. (See
 //   ParallelArray.js for a discussion of specifically how we do this
 //   in the case of ParallelArray).
 //
 // - Try to execute the code in parallel.  Parallel execution mode has
 //   three possible results: success, fatal error, or bailout.  If a
 //   bailout occurs, it means that the code attempted some action
 //   which is not possible in parallel mode.  This might be a
 //   modification to shared state, but it might also be that it
 //   attempted to take some theoreticaly pure action that has not been
 //   made threadsafe (yet?).
 //
 // - If parallel execution is successful, ForkJoin returns true.
 //
 // - If parallel execution results in a fatal error, ForkJoin returns false.
 //
 // - If parallel execution results in a *bailout*, this is when things
 //   get interesting.  In that case, the semantics of parallel
 //   execution guarantee us that no visible side effects have occurred
 //   (unless they were performed with the intrinsic
 //   |UnsafePutElements()|, which can only be used in self-hosted
 //   code).  We therefore reinvoke |func()| but with warmup set to
 //   true.  The idea here is that often parallel bailouts result from
 //   a failed type guard or other similar assumption, so rerunning the
 //   warmup sequentially gives us a chance to recompile with more
 //   data.  Because warmup is true, we do not expect this sequential
 //   call to process all remaining data, just a chunk.  After this
 //   recovery execution is complete, we again attempt parallel
 //   execution.
 //
 // - If more than a fixed number of bailouts occur, we give up on
 //   parallelization and just invoke |func()| N times in a row (once
 //   for each worker) but with |warmup| set to false.
 //
 // Interrupts:
 //
 // During parallel execution, |cx.check()| must be periodically invoked to
 // check for interrupts. This is automatically done by the Ion-generated
 // code. If an interrupt has been requested |cx.check()| aborts parallel
 // execution.
 //
 // Transitive compilation:
 //
 // One of the challenges for parallel compilation is that we
 // (currently) have to abort when we encounter an uncompiled script.
 // Therefore, we try to compile everything that might be needed
 // beforehand. The exact strategy is described in `ParallelDo::apply()`
 // in ForkJoin.cpp, but at the highest level the idea is:
 //
 // 1. We maintain a flag on every script telling us if that script and
 //    its transitive callees are believed to be compiled. If that flag
 //    is set, we can skip the initial compilation.
 // 2. Otherwise, we maintain a worklist that begins with the main
 //    script. We compile it and then examine the generated parallel IonScript,
 //    which will have a list of callees. We enqueue those. Some of these
 //    compilations may take place off the main thread, in which case
 //    we will run warmup iterations while we wait for them to complete.
 // 3. If the warmup iterations finish all the work, we're done.
 // 4. If compilations fail, we fallback to sequential.
 // 5. Otherwise, we will try running in parallel once we're all done.
 //
 // Bailout tracing and recording:
 //
 // When a bailout occurs, we record a bit of state so that we can
 // recover with grace. Each |ForkJoinContext| has a pointer to a
 // |ParallelBailoutRecord| pre-allocated for this purpose. This
 // structure is used to record the cause of the bailout, the JSScript
 // which was executing, as well as the location in the source where
 // the bailout occurred (in principle, we can record a full stack
 // trace, but right now we only record the top-most frame). Note that
 // the error location might not be in the same JSScript as the one
 // which was executing due to inlining.
 //
 // Garbage collection and allocation:
 //
 // Code which executes on these parallel threads must be very careful
 // with respect to garbage collection and allocation.  The typical
 // allocation paths are UNSAFE in parallel code because they access
 // shared state (the compartment's arena lists and so forth) without
 // any synchronization.  They can also trigger GC in an ad-hoc way.
 //
 // To deal with this, the forkjoin code creates a distinct |Allocator|
 // object for each slice.  You can access the appropriate object via
 // the |ForkJoinContext| object that is provided to the callbacks.  Once
 // the execution is complete, all the objects found in these distinct
 // |Allocator| is merged back into the main compartment lists and
 // things proceed normally.
 //
 // In Ion-generated code, we will do allocation through the
 // |Allocator| found in |ForkJoinContext| (which is obtained via TLS).
 // Also, no write barriers are emitted.  Conceptually, we should never
 // need a write barrier because we only permit writes to objects that
 // are newly allocated, and such objects are always black (to use
 // incremental GC terminology).  However, to be safe, we also block
 // upon entering a parallel section to ensure that any concurrent
 // marking or incremental GC has completed.
 //
 // In the future, it should be possible to lift the restriction that
 // we must block until inc. GC has completed and also to permit GC
 // during parallel exeution. But we're not there yet.
 //
 // Load balancing (work stealing):
 //
 // The ForkJoin job is dynamically divided into a fixed number of slices,
 // and is submitted for parallel execution in the pool. When the number
 // of slices is big enough (typically greater than the number of workers
 // in the pool) -and the workload is unbalanced- each worker thread
 // will perform load balancing through work stealing. The number
 // of slices is computed by the self-hosted function |ComputeNumSlices|
 // and can be used to know how many slices will be executed by the
 // runtime for an array of the given size.
 //
 // Current Limitations:
 //
 // - The API does not support recursive or nested use.  That is, the
 //   JavaScript function given to |ForkJoin| should not itself invoke
 //   |ForkJoin()|. Instead, use the intrinsic |InParallelSection()| to
 //   check for recursive use and execute a sequential fallback.
 //
 ///////////////////////////////////////////////////////////////////////////
 namespace js {
 class ForkJoinActivation : public Activation
 {
     uint8_t *prevIonTop_;
     // We ensure that incremental GC be finished before we enter into a fork
     // join section, but the runtime/zone might still be marked as needing
     // barriers due to being in the middle of verifying barriers. Pause
     // verification during the fork join section.
     gc::AutoStopVerifyingBarriers av_;
   public:
     ForkJoinActivation(JSContext *cx);
     ~ForkJoinActivation();
 };
 class ForkJoinContext;
 bool ForkJoin(JSContext *cx, CallArgs &args);
 struct IonLIRTraceData {
     uint32_t blockIndex;
     uint32_t lirIndex;
     uint32_t execModeInt;
     const char *lirOpName;
     const char *mirOpName;
     JSScript *script;
     jsbytecode *pc;
 };
 ///////////////////////////////////////////////////////////////////////////
 // Bailout tracking
 enum ParallelBailoutCause {
     ParallelBailoutNone,
     // Compiler returned Method_Skipped
     ParallelBailoutCompilationSkipped,
     // Compiler returned Method_CantCompile
     ParallelBailoutCompilationFailure,
     // The periodic interrupt failed, which can mean that either
     // another thread canceled, the user interrupted us, etc
     ParallelBailoutInterrupt,
     // An IC update failed
     ParallelBailoutFailedIC,
     // Heap busy flag was set during interrupt
     ParallelBailoutHeapBusy,
     ParallelBailoutMainScriptNotPresent,
     ParallelBailoutCalledToUncompiledScript,
     ParallelBailoutIllegalWrite,
     ParallelBailoutAccessToIntrinsic,
     ParallelBailoutOverRecursed,
     ParallelBailoutOutOfMemory,
     ParallelBailoutUnsupported,
     ParallelBailoutUnsupportedVM,
     ParallelBailoutUnsupportedStringComparison,
     ParallelBailoutRequestedGC,
     ParallelBailoutRequestedZoneGC,
 };
 struct ParallelBailoutTrace {
     JSScript *script;
     jsbytecode *bytecode;
 };
 // See "Bailouts" section in comment above.
 struct ParallelBailoutRecord {
     JSScript *topScript;
     ParallelBailoutCause cause;
     // Eventually we will support deeper traces,
     // but for now we gather at most a single frame.
     static const uint32_t MaxDepth = 1;
     uint32_t depth;
     ParallelBailoutTrace trace[MaxDepth];
     void init(JSContext *cx);
     void reset(JSContext *cx);
     void setCause(ParallelBailoutCause cause,
                   JSScript *outermostScript = nullptr,   // inliner (if applicable)
                   JSScript *currentScript = nullptr,     // inlinee (if applicable)
                   jsbytecode *currentPc = nullptr);
     void updateCause(ParallelBailoutCause cause,
                      JSScript *outermostScript,
                      JSScript *currentScript,
                      jsbytecode *currentPc);
     void addTrace(JSScript *script,
                   jsbytecode *pc);
 };
 struct ForkJoinShared;
 class ForkJoinContext : public ThreadSafeContext
 {
   public:
     // Bailout record used to record the reason this thread stopped executing
     ParallelBailoutRecord *const bailoutRecord;
 #ifdef DEBUG
     // Records the last instr. to execute on this thread.
     IonLIRTraceData traceData;
     // The maximum worker id.
     uint32_t maxWorkerId;
 #endif
     // When we run a par operation like mapPar, we create an out pointer
     // into a specific region of the destination buffer. Even though the
     // destination buffer is not thread-local, it is permissible to write into
     // it via the handles provided. These two fields identify the memory
     // region where writes are allowed so that the write guards can test for
     // it.
     //
     // Note: we only permit writes into the *specific region* that the user
     // is supposed to write. Normally, they only have access to this region
     // anyhow. But due to sequential fallback it is possible for handles into
     // other regions to escape into global variables in the sequential
     // execution and then get accessed by later parallel sections. Thus we
     // must be careful and ensure that the write is going through a handle
     // into the correct *region* of the buffer.
     uint8_t *targetRegionStart;
     uint8_t *targetRegionEnd;
     ForkJoinContext(PerThreadData *perThreadData, ThreadPoolWorker *worker,
                     Allocator *allocator, ForkJoinShared *shared,
                     ParallelBailoutRecord *bailoutRecord);
     // Get the worker id. The main thread by convention has the id of the max
     // worker thread id + 1.
     uint32_t workerId() const { return worker_->id(); }
     // Get a slice of work for the worker associated with the context.
     bool getSlice(uint16_t *sliceId) { return worker_->getSlice(this, sliceId); }
     // True if this is the main thread, false if it is one of the parallel workers.
     bool isMainThread() const;
     // When the code would normally trigger a GC, we don't trigger it
     // immediately but instead record that request here.  This will
     // cause |ExecuteForkJoinOp()| to invoke |TriggerGC()| or
     // |TriggerCompartmentGC()| as appropriate once the parallel
     // section is complete. This is done because those routines do
     // various preparations that are not thread-safe, and because the
     // full set of arenas is not available until the end of the
     // parallel section.
     void requestGC(JS::gcreason::Reason reason);
     void requestZoneGC(JS::Zone *zone, JS::gcreason::Reason reason);
     // Set the fatal flag for the next abort. Used to distinguish retry or
     // fatal aborts from VM functions.
     bool setPendingAbortFatal(ParallelBailoutCause cause);
     // Reports an unsupported operation, returning false if we are reporting
     // an error. Otherwise drop the warning on the floor.
     bool reportError(ParallelBailoutCause cause, unsigned report) {
         if (report & JSREPORT_ERROR)
             return setPendingAbortFatal(cause);
         return true;
     }
     // During the parallel phase, this method should be invoked
     // periodically, for example on every backedge, similar to the
     // interrupt check.  If it returns false, then the parallel phase
     // has been aborted and so you should bailout.  The function may
     // also rendesvous to perform GC or do other similar things.
     //
     // This function is guaranteed to have no effect if both
     // runtime()->interruptPar is zero.  Ion-generated code takes
     // advantage of this by inlining the checks on those flags before
     // actually calling this function.  If this function ends up
     // getting called a lot from outside ion code, we can refactor
     // it into an inlined version with this check that calls a slower
     // version.
     bool check();
     // Be wary, the runtime is shared between all threads!
     JSRuntime *runtime();
     // Acquire and release the JSContext from the runtime.
     JSContext *acquireJSContext();
     void releaseJSContext();
     bool hasAcquiredJSContext() const;
     // Check the current state of parallel execution.
     static inline ForkJoinContext *current();
     // Initializes the thread-local state.
     static bool initialize();
     // Used in inlining GetForkJoinSlice.
     static size_t offsetOfWorker() {
         return offsetof(ForkJoinContext, worker_);
     }
   private:
     friend class AutoSetForkJoinContext;
     // Initialized by initialize()
     static mozilla::ThreadLocal<ForkJoinContext*> tlsForkJoinContext;
     ForkJoinShared *const shared_;
     ThreadPoolWorker *worker_;
     bool acquiredJSContext_;
     // ForkJoinContext is allocated on the stack. It would be dangerous to GC
     // with it live because of the GC pointer fields stored in the context.
     JS::AutoAssertNoGC nogc_;
 };
 // Locks a JSContext for its scope. Be very careful, because locking a
 // JSContext does *not* allow you to safely mutate the data in the
 // JSContext unless you can guarantee that any of the other threads
 // that want to access that data will also acquire the lock, which is
 // generally not the case. For example, the lock is used in the IC
 // code to allow us to atomically patch up the dispatch table, but we
 // must be aware that other threads may be reading from the table even
 // as we write to it (though they cannot be writing, since they must
 // hold the lock to write).
 class LockedJSContext
 {
 #if defined(JS_THREADSAFE) && defined(JS_ION)
     ForkJoinContext *cx_;
 #endif
     JSContext *jscx_;
   public:
     LockedJSContext(ForkJoinContext *cx)
 #if defined(JS_THREADSAFE) && defined(JS_ION)
       : cx_(cx),
         jscx_(cx->acquireJSContext())
 #else
       : jscx_(nullptr)
 #endif
     { }
     ~LockedJSContext() {
 #if defined(JS_THREADSAFE) && defined(JS_ION)
         cx_->releaseJSContext();
 #endif
     }
     operator JSContext *() { return jscx_; }
     JSContext *operator->() { return jscx_; }
 };
 bool InExclusiveParallelSection();
 bool ParallelTestsShouldPass(JSContext *cx);
 void RequestInterruptForForkJoin(JSRuntime *rt, JSRuntime::InterruptMode mode);
 bool intrinsic_SetForkJoinTargetRegion(JSContext *cx, unsigned argc, Value *vp);
 extern const JSJitInfo intrinsic_SetForkJoinTargetRegionInfo;
 bool intrinsic_ClearThreadLocalArenas(JSContext *cx, unsigned argc, Value *vp);
 extern const JSJitInfo intrinsic_ClearThreadLocalArenasInfo;
 ///////////////////////////////////////////////////////////////////////////
 // Debug Spew
 namespace jit {
     class MDefinition;
 }
 namespace parallel {
 enum ExecutionStatus {
     // Parallel or seq execution terminated in a fatal way, operation failed
     ExecutionFatal,
     // Parallel exec failed and so we fell back to sequential
     ExecutionSequential,
     // We completed the work in seq mode before parallel compilation completed
     ExecutionWarmup,
     // Parallel exec was successful after some number of bailouts
     ExecutionParallel
 };
 enum SpewChannel {
     SpewOps,
     SpewCompile,
     SpewBailouts,
     NumSpewChannels
 };
 #if defined(DEBUG) && defined(JS_THREADSAFE) && defined(JS_ION)
 bool SpewEnabled(SpewChannel channel);
 void Spew(SpewChannel channel, const char *fmt, ...);
 void SpewBeginOp(JSContext *cx, const char *name);
 void SpewBailout(uint32_t count, HandleScript script, jsbytecode *pc,
                  ParallelBailoutCause cause);
 ExecutionStatus SpewEndOp(ExecutionStatus status);
 void SpewBeginCompile(HandleScript script);
 jit::MethodStatus SpewEndCompile(jit::MethodStatus status);
 void SpewMIR(jit::MDefinition *mir, const char *fmt, ...);
 void SpewBailoutIR(IonLIRTraceData *data);
 #else
 static inline bool SpewEnabled(SpewChannel channel) { return false; }
 static inline void Spew(SpewChannel channel, const char *fmt, ...) { }
 static inline void SpewBeginOp(JSContext *cx, const char *name) { }
 static inline void SpewBailout(uint32_t count, HandleScript script,
                                jsbytecode *pc, ParallelBailoutCause cause) {}
 static inline ExecutionStatus SpewEndOp(ExecutionStatus status) { return status; }
 static inline void SpewBeginCompile(HandleScript script) { }
 #ifdef JS_ION
 static inline jit::MethodStatus SpewEndCompile(jit::MethodStatus status) { return status; }
 static inline void SpewMIR(jit::MDefinition *mir, const char *fmt, ...) { }
 #endif
 static inline void SpewBailoutIR(IonLIRTraceData *data) { }
 #endif // DEBUG && JS_THREADSAFE && JS_ION
 } // namespace parallel
 } // namespace js
 /* static */ inline js::ForkJoinContext *
 js::ForkJoinContext::current()
 {
     return tlsForkJoinContext.get();
 }
 namespace js {
 static inline bool
 InParallelSection()
 {
     return ForkJoinContext::current() != nullptr;
 }
 } // namespace js
 #endif /* vm_ForkJoin_h */

The Tor Browser / annotate

js/src/vm/ForkJoin.h@129ffea94266 (annotated)

js/src/vm/ForkJoin.h