The Tor Browser / file comparison

comparison: js/src/jsworkers.cpp

js/src/jsworkers.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:97d5ffd6d315
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 * vim: set ts=8 sts=4 et sw=4 tw=99:
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #include "jsworkers.h"
8
9 #ifdef JS_THREADSAFE
10
11 #include "mozilla/DebugOnly.h"
12
13 #include "jsnativestack.h"
14 #include "prmjtime.h"
15
16 #include "frontend/BytecodeCompiler.h"
17 #include "jit/IonBuilder.h"
18 #include "vm/Debugger.h"
19 #include "vm/TraceLogging.h"
20
21 #include "jscntxtinlines.h"
22 #include "jscompartmentinlines.h"
23 #include "jsobjinlines.h"
24 #include "jsscriptinlines.h"
25
26 using namespace js;
27
28 using mozilla::ArrayLength;
29 using mozilla::DebugOnly;
30
31 namespace js {
32
33 GlobalWorkerThreadState gWorkerThreadState;
34
35 } // namespace js
36
37 void
38 js::EnsureWorkerThreadsInitialized(ExclusiveContext *cx)
39 {
40 // If 'cx' is not a JSContext, we are already off the main thread and the
41 // worker threads would have already been initialized.
42 if (!cx->isJSContext())
43 return;
44
45 WorkerThreadState().ensureInitialized();
46 }
47
48 static size_t
49 ThreadCountForCPUCount(size_t cpuCount)
50 {
51 return Max(cpuCount, (size_t)2);
52 }
53
54 void
55 js::SetFakeCPUCount(size_t count)
56 {
57 // This must be called before the threads have been initialized.
58 JS_ASSERT(!WorkerThreadState().threads);
59
60 WorkerThreadState().cpuCount = count;
61 WorkerThreadState().threadCount = ThreadCountForCPUCount(count);
62 }
63
64 #ifdef JS_ION
65
66 bool
67 js::StartOffThreadAsmJSCompile(ExclusiveContext *cx, AsmJSParallelTask *asmData)
68 {
69 // Threads already initialized by the AsmJS compiler.
70 JS_ASSERT(asmData->mir);
71 JS_ASSERT(asmData->lir == nullptr);
72
73 AutoLockWorkerThreadState lock;
74
75 // Don't append this task if another failed.
76 if (WorkerThreadState().asmJSWorkerFailed())
77 return false;
78
79 if (!WorkerThreadState().asmJSWorklist().append(asmData))
80 return false;
81
82 WorkerThreadState().notifyOne(GlobalWorkerThreadState::PRODUCER);
83 return true;
84 }
85
86 bool
87 js::StartOffThreadIonCompile(JSContext *cx, jit::IonBuilder *builder)
88 {
89 EnsureWorkerThreadsInitialized(cx);
90
91 AutoLockWorkerThreadState lock;
92
93 if (!WorkerThreadState().ionWorklist().append(builder))
94 return false;
95
96 WorkerThreadState().notifyOne(GlobalWorkerThreadState::PRODUCER);
97 return true;
98 }
99
100 /*
101 * Move an IonBuilder for which compilation has either finished, failed, or
102 * been cancelled into the global finished compilation list. All off thread
103 * compilations which are started must eventually be finished.
104 */
105 static void
106 FinishOffThreadIonCompile(jit::IonBuilder *builder)
107 {
108 WorkerThreadState().ionFinishedList().append(builder);
109 }
110
111 #endif // JS_ION
112
113 static inline bool
114 CompiledScriptMatches(JSCompartment *compartment, JSScript *script, JSScript *target)
115 {
116 if (script)
117 return target == script;
118 return target->compartment() == compartment;
119 }
120
121 void
122 js::CancelOffThreadIonCompile(JSCompartment *compartment, JSScript *script)
123 {
124 #ifdef JS_ION
125 jit::JitCompartment *jitComp = compartment->jitCompartment();
126 if (!jitComp)
127 return;
128
129 AutoLockWorkerThreadState lock;
130
131 if (!WorkerThreadState().threads)
132 return;
133
134 /* Cancel any pending entries for which processing hasn't started. */
135 GlobalWorkerThreadState::IonBuilderVector &worklist = WorkerThreadState().ionWorklist();
136 for (size_t i = 0; i < worklist.length(); i++) {
137 jit::IonBuilder *builder = worklist[i];
138 if (CompiledScriptMatches(compartment, script, builder->script())) {
139 FinishOffThreadIonCompile(builder);
140 WorkerThreadState().remove(worklist, &i);
141 }
142 }
143
144 /* Wait for in progress entries to finish up. */
145 for (size_t i = 0; i < WorkerThreadState().threadCount; i++) {
146 const WorkerThread &helper = WorkerThreadState().threads[i];
147 while (helper.ionBuilder &&
148 CompiledScriptMatches(compartment, script, helper.ionBuilder->script()))
149 {
150 helper.ionBuilder->cancel();
151 WorkerThreadState().wait(GlobalWorkerThreadState::CONSUMER);
152 }
153 }
154
155 /* Cancel code generation for any completed entries. */
156 GlobalWorkerThreadState::IonBuilderVector &finished = WorkerThreadState().ionFinishedList();
157 for (size_t i = 0; i < finished.length(); i++) {
158 jit::IonBuilder *builder = finished[i];
159 if (CompiledScriptMatches(compartment, script, builder->script())) {
160 jit::FinishOffThreadBuilder(builder);
161 WorkerThreadState().remove(finished, &i);
162 }
163 }
164 #endif // JS_ION
165 }
166
167 static const JSClass workerGlobalClass = {
168 "internal-worker-global", JSCLASS_GLOBAL_FLAGS,
169 JS_PropertyStub, JS_DeletePropertyStub,
170 JS_PropertyStub, JS_StrictPropertyStub,
171 JS_EnumerateStub, JS_ResolveStub,
172 JS_ConvertStub, nullptr,
173 nullptr, nullptr, nullptr,
174 JS_GlobalObjectTraceHook
175 };
176
177 ParseTask::ParseTask(ExclusiveContext *cx, JSObject *exclusiveContextGlobal, JSContext *initCx,
178 const jschar *chars, size_t length,
179 JS::OffThreadCompileCallback callback, void *callbackData)
180 : cx(cx), options(initCx), chars(chars), length(length),
181 alloc(JSRuntime::TEMP_LIFO_ALLOC_PRIMARY_CHUNK_SIZE),
182 exclusiveContextGlobal(initCx, exclusiveContextGlobal), optionsElement(initCx),
183 optionsIntroductionScript(initCx), callback(callback), callbackData(callbackData),
184 script(nullptr), errors(cx), overRecursed(false)
185 {
186 }
187
188 bool
189 ParseTask::init(JSContext *cx, const ReadOnlyCompileOptions &options)
190 {
191 if (!this->options.copy(cx, options))
192 return false;
193
194 // Save those compilation options that the ScriptSourceObject can't
195 // point at while it's in the compilation's temporary compartment.
196 optionsElement = this->options.element();
197 this->options.setElement(nullptr);
198 optionsIntroductionScript = this->options.introductionScript();
199 this->options.setIntroductionScript(nullptr);
200
201 return true;
202 }
203
204 void
205 ParseTask::activate(JSRuntime *rt)
206 {
207 rt->setUsedByExclusiveThread(exclusiveContextGlobal->zone());
208 cx->enterCompartment(exclusiveContextGlobal->compartment());
209 }
210
211 void
212 ParseTask::finish()
213 {
214 if (script) {
215 // Initialize the ScriptSourceObject slots that we couldn't while the SSO
216 // was in the temporary compartment.
217 ScriptSourceObject &sso = script->sourceObject()->as<ScriptSourceObject>();
218 sso.initElement(optionsElement);
219 sso.initIntroductionScript(optionsIntroductionScript);
220 }
221 }
222
223 ParseTask::~ParseTask()
224 {
225 // ParseTask takes over ownership of its input exclusive context.
226 js_delete(cx);
227
228 for (size_t i = 0; i < errors.length(); i++)
229 js_delete(errors[i]);
230 }
231
232 void
233 js::CancelOffThreadParses(JSRuntime *rt)
234 {
235 AutoLockWorkerThreadState lock;
236
237 if (!WorkerThreadState().threads)
238 return;
239
240 // Instead of forcibly canceling pending parse tasks, just wait for all scheduled
241 // and in progress ones to complete. Otherwise the final GC may not collect
242 // everything due to zones being used off thread.
243 while (true) {
244 bool pending = false;
245 GlobalWorkerThreadState::ParseTaskVector &worklist = WorkerThreadState().parseWorklist();
246 for (size_t i = 0; i < worklist.length(); i++) {
247 ParseTask *task = worklist[i];
248 if (task->runtimeMatches(rt))
249 pending = true;
250 }
251 if (!pending) {
252 bool inProgress = false;
253 for (size_t i = 0; i < WorkerThreadState().threadCount; i++) {
254 ParseTask *task = WorkerThreadState().threads[i].parseTask;
255 if (task && task->runtimeMatches(rt))
256 inProgress = true;
257 }
258 if (!inProgress)
259 break;
260 }
261 WorkerThreadState().wait(GlobalWorkerThreadState::CONSUMER);
262 }
263
264 // Clean up any parse tasks which haven't been finished by the main thread.
265 GlobalWorkerThreadState::ParseTaskVector &finished = WorkerThreadState().parseFinishedList();
266 while (true) {
267 bool found = false;
268 for (size_t i = 0; i < finished.length(); i++) {
269 ParseTask *task = finished[i];
270 if (task->runtimeMatches(rt)) {
271 found = true;
272 AutoUnlockWorkerThreadState unlock;
273 WorkerThreadState().finishParseTask(/* maybecx = */ nullptr, rt, task);
274 }
275 }
276 if (!found)
277 break;
278 }
279 }
280
281 bool
282 js::OffThreadParsingMustWaitForGC(JSRuntime *rt)
283 {
284 // Off thread parsing can't occur during incremental collections on the
285 // atoms compartment, to avoid triggering barriers. (Outside the atoms
286 // compartment, the compilation will use a new zone that is never
287 // collected.) If an atoms-zone GC is in progress, hold off on executing the
288 // parse task until the atoms-zone GC completes (see
289 // EnqueuePendingParseTasksAfterGC).
290 return rt->activeGCInAtomsZone();
291 }
292
293 bool
294 js::StartOffThreadParseScript(JSContext *cx, const ReadOnlyCompileOptions &options,
295 const jschar *chars, size_t length,
296 JS::OffThreadCompileCallback callback, void *callbackData)
297 {
298 // Suppress GC so that calls below do not trigger a new incremental GC
299 // which could require barriers on the atoms compartment.
300 gc::AutoSuppressGC suppress(cx);
301
302 SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::NoOwnership);
303 frontend::MaybeCallSourceHandler(cx, options, srcBuf);
304
305 EnsureWorkerThreadsInitialized(cx);
306
307 JS::CompartmentOptions compartmentOptions(cx->compartment()->options());
308 compartmentOptions.setZone(JS::FreshZone);
309 compartmentOptions.setInvisibleToDebugger(true);
310 compartmentOptions.setMergeable(true);
311
312 // Don't falsely inherit the host's global trace hook.
313 compartmentOptions.setTrace(nullptr);
314
315 JSObject *global = JS_NewGlobalObject(cx, &workerGlobalClass, nullptr,
316 JS::FireOnNewGlobalHook, compartmentOptions);
317 if (!global)
318 return false;
319
320 JS_SetCompartmentPrincipals(global->compartment(), cx->compartment()->principals);
321
322 RootedObject obj(cx);
323
324 // Initialize all classes needed for parsing while we are still on the main
325 // thread. Do this for both the target and the new global so that prototype
326 // pointers can be changed infallibly after parsing finishes.
327 if (!GetBuiltinConstructor(cx, JSProto_Function, &obj) ||
328 !GetBuiltinConstructor(cx, JSProto_Array, &obj) ||
329 !GetBuiltinConstructor(cx, JSProto_RegExp, &obj) ||
330 !GetBuiltinConstructor(cx, JSProto_Iterator, &obj))
331 {
332 return false;
333 }
334 {
335 AutoCompartment ac(cx, global);
336 if (!GetBuiltinConstructor(cx, JSProto_Function, &obj) ||
337 !GetBuiltinConstructor(cx, JSProto_Array, &obj) ||
338 !GetBuiltinConstructor(cx, JSProto_RegExp, &obj) ||
339 !GetBuiltinConstructor(cx, JSProto_Iterator, &obj))
340 {
341 return false;
342 }
343 }
344
345 ScopedJSDeletePtr<ExclusiveContext> workercx(
346 cx->new_<ExclusiveContext>(cx->runtime(), (PerThreadData *) nullptr,
347 ThreadSafeContext::Context_Exclusive));
348 if (!workercx)
349 return false;
350
351 ScopedJSDeletePtr<ParseTask> task(
352 cx->new_<ParseTask>(workercx.get(), global, cx, chars, length,
353 callback, callbackData));
354 if (!task)
355 return false;
356
357 workercx.forget();
358
359 if (!task->init(cx, options))
360 return false;
361
362 if (OffThreadParsingMustWaitForGC(cx->runtime())) {
363 AutoLockWorkerThreadState lock;
364 if (!WorkerThreadState().parseWaitingOnGC().append(task.get()))
365 return false;
366 } else {
367 task->activate(cx->runtime());
368
369 AutoLockWorkerThreadState lock;
370
371 if (!WorkerThreadState().parseWorklist().append(task.get()))
372 return false;
373
374 WorkerThreadState().notifyOne(GlobalWorkerThreadState::PRODUCER);
375 }
376
377 task.forget();
378
379 return true;
380 }
381
382 void
383 js::EnqueuePendingParseTasksAfterGC(JSRuntime *rt)
384 {
385 JS_ASSERT(!OffThreadParsingMustWaitForGC(rt));
386
387 GlobalWorkerThreadState::ParseTaskVector newTasks;
388 {
389 AutoLockWorkerThreadState lock;
390 GlobalWorkerThreadState::ParseTaskVector &waiting = WorkerThreadState().parseWaitingOnGC();
391
392 for (size_t i = 0; i < waiting.length(); i++) {
393 ParseTask *task = waiting[i];
394 if (task->runtimeMatches(rt)) {
395 newTasks.append(task);
396 WorkerThreadState().remove(waiting, &i);
397 }
398 }
399 }
400
401 if (newTasks.empty())
402 return;
403
404 // This logic should mirror the contents of the !activeGCInAtomsZone()
405 // branch in StartOffThreadParseScript:
406
407 for (size_t i = 0; i < newTasks.length(); i++)
408 newTasks[i]->activate(rt);
409
410 AutoLockWorkerThreadState lock;
411
412 for (size_t i = 0; i < newTasks.length(); i++)
413 WorkerThreadState().parseWorklist().append(newTasks[i]);
414
415 WorkerThreadState().notifyAll(GlobalWorkerThreadState::PRODUCER);
416 }
417
418 static const uint32_t WORKER_STACK_SIZE = 512 * 1024;
419 static const uint32_t WORKER_STACK_QUOTA = 450 * 1024;
420
421 void
422 GlobalWorkerThreadState::ensureInitialized()
423 {
424 JS_ASSERT(this == &WorkerThreadState());
425 AutoLockWorkerThreadState lock;
426
427 if (threads)
428 return;
429
430 threads = js_pod_calloc<WorkerThread>(threadCount);
431 if (!threads)
432 CrashAtUnhandlableOOM("GlobalWorkerThreadState::ensureInitialized");
433
434 for (size_t i = 0; i < threadCount; i++) {
435 WorkerThread &helper = threads[i];
436 helper.threadData.construct(static_cast<JSRuntime *>(nullptr));
437 helper.thread = PR_CreateThread(PR_USER_THREAD,
438 WorkerThread::ThreadMain, &helper,
439 PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, WORKER_STACK_SIZE);
440 if (!helper.thread || !helper.threadData.ref().init())
441 CrashAtUnhandlableOOM("GlobalWorkerThreadState::ensureInitialized");
442 }
443
444 resetAsmJSFailureState();
445 }
446
447 GlobalWorkerThreadState::GlobalWorkerThreadState()
448 {
449 mozilla::PodZero(this);
450
451 cpuCount = GetCPUCount();
452 threadCount = ThreadCountForCPUCount(cpuCount);
453
454 MOZ_ASSERT(cpuCount > 0, "GetCPUCount() seems broken");
455
456 workerLock = PR_NewLock();
457 consumerWakeup = PR_NewCondVar(workerLock);
458 producerWakeup = PR_NewCondVar(workerLock);
459 }
460
461 void
462 GlobalWorkerThreadState::finish()
463 {
464 if (threads) {
465 for (size_t i = 0; i < threadCount; i++)
466 threads[i].destroy();
467 js_free(threads);
468 }
469
470 PR_DestroyCondVar(consumerWakeup);
471 PR_DestroyCondVar(producerWakeup);
472 PR_DestroyLock(workerLock);
473 }
474
475 void
476 GlobalWorkerThreadState::lock()
477 {
478 JS_ASSERT(!isLocked());
479 AssertCurrentThreadCanLock(WorkerThreadStateLock);
480 PR_Lock(workerLock);
481 #ifdef DEBUG
482 lockOwner = PR_GetCurrentThread();
483 #endif
484 }
485
486 void
487 GlobalWorkerThreadState::unlock()
488 {
489 JS_ASSERT(isLocked());
490 #ifdef DEBUG
491 lockOwner = nullptr;
492 #endif
493 PR_Unlock(workerLock);
494 }
495
496 #ifdef DEBUG
497 bool
498 GlobalWorkerThreadState::isLocked()
499 {
500 return lockOwner == PR_GetCurrentThread();
501 }
502 #endif
503
504 void
505 GlobalWorkerThreadState::wait(CondVar which, uint32_t millis)
506 {
507 JS_ASSERT(isLocked());
508 #ifdef DEBUG
509 lockOwner = nullptr;
510 #endif
511 DebugOnly<PRStatus> status =
512 PR_WaitCondVar((which == CONSUMER) ? consumerWakeup : producerWakeup,
513 millis ? PR_MillisecondsToInterval(millis) : PR_INTERVAL_NO_TIMEOUT);
514 JS_ASSERT(status == PR_SUCCESS);
515 #ifdef DEBUG
516 lockOwner = PR_GetCurrentThread();
517 #endif
518 }
519
520 void
521 GlobalWorkerThreadState::notifyAll(CondVar which)
522 {
523 JS_ASSERT(isLocked());
524 PR_NotifyAllCondVar((which == CONSUMER) ? consumerWakeup : producerWakeup);
525 }
526
527 void
528 GlobalWorkerThreadState::notifyOne(CondVar which)
529 {
530 JS_ASSERT(isLocked());
531 PR_NotifyCondVar((which == CONSUMER) ? consumerWakeup : producerWakeup);
532 }
533
534 bool
535 GlobalWorkerThreadState::canStartAsmJSCompile()
536 {
537 // Don't execute an AsmJS job if an earlier one failed.
538 JS_ASSERT(isLocked());
539 return !asmJSWorklist().empty() && !numAsmJSFailedJobs;
540 }
541
542 bool
543 GlobalWorkerThreadState::canStartIonCompile()
544 {
545 // A worker thread can begin an Ion compilation if (a) there is some script
546 // which is waiting to be compiled, and (b) no other worker thread is
547 // currently compiling a script. The latter condition ensures that two
548 // compilations cannot simultaneously occur.
549 if (ionWorklist().empty())
550 return false;
551 for (size_t i = 0; i < threadCount; i++) {
552 if (threads[i].ionBuilder)
553 return false;
554 }
555 return true;
556 }
557
558 bool
559 GlobalWorkerThreadState::canStartParseTask()
560 {
561 // Don't allow simultaneous off thread parses, to reduce contention on the
562 // atoms table. Note that asm.js compilation depends on this to avoid
563 // stalling the worker thread, as off thread parse tasks can trigger and
564 // block on other off thread asm.js compilation tasks.
565 JS_ASSERT(isLocked());
566 if (parseWorklist().empty())
567 return false;
568 for (size_t i = 0; i < threadCount; i++) {
569 if (threads[i].parseTask)
570 return false;
571 }
572 return true;
573 }
574
575 bool
576 GlobalWorkerThreadState::canStartCompressionTask()
577 {
578 return !compressionWorklist().empty();
579 }
580
581 static void
582 CallNewScriptHookForAllScripts(JSContext *cx, HandleScript script)
583 {
584 // We should never hit this, since nested scripts are also constructed via
585 // BytecodeEmitter instances on the stack.
586 JS_CHECK_RECURSION(cx, return);
587
588 // Recurse to any nested scripts.
589 if (script->hasObjects()) {
590 ObjectArray *objects = script->objects();
591 for (size_t i = 0; i < objects->length; i++) {
592 JSObject *obj = objects->vector[i];
593 if (obj->is<JSFunction>()) {
594 JSFunction *fun = &obj->as<JSFunction>();
595 if (fun->hasScript()) {
596 RootedScript nested(cx, fun->nonLazyScript());
597 CallNewScriptHookForAllScripts(cx, nested);
598 }
599 }
600 }
601 }
602
603 // The global new script hook is called on every script that was compiled.
604 RootedFunction function(cx, script->functionNonDelazifying());
605 CallNewScriptHook(cx, script, function);
606 }
607
608 static void
609 LeaveParseTaskZone(JSRuntime *rt, ParseTask *task)
610 {
611 // Mark the zone as no longer in use by an ExclusiveContext, and available
612 // to be collected by the GC.
613 rt->clearUsedByExclusiveThread(task->cx->zone());
614 }
615
616 JSScript *
617 GlobalWorkerThreadState::finishParseTask(JSContext *maybecx, JSRuntime *rt, void *token)
618 {
619 ScopedJSDeletePtr<ParseTask> parseTask;
620
621 // The token is a ParseTask* which should be in the finished list.
622 // Find and remove its entry.
623 {
624 AutoLockWorkerThreadState lock;
625 ParseTaskVector &finished = parseFinishedList();
626 for (size_t i = 0; i < finished.length(); i++) {
627 if (finished[i] == token) {
628 parseTask = finished[i];
629 remove(finished, &i);
630 break;
631 }
632 }
633 }
634 JS_ASSERT(parseTask);
635
636 if (!maybecx) {
637 LeaveParseTaskZone(rt, parseTask);
638 return nullptr;
639 }
640
641 JSContext *cx = maybecx;
642 JS_ASSERT(cx->compartment());
643
644 // Make sure we have all the constructors we need for the prototype
645 // remapping below, since we can't GC while that's happening.
646 Rooted<GlobalObject*> global(cx, &cx->global()->as<GlobalObject>());
647 if (!GlobalObject::ensureConstructor(cx, global, JSProto_Object) ||
648 !GlobalObject::ensureConstructor(cx, global, JSProto_Array) ||
649 !GlobalObject::ensureConstructor(cx, global, JSProto_Function) ||
650 !GlobalObject::ensureConstructor(cx, global, JSProto_RegExp) ||
651 !GlobalObject::ensureConstructor(cx, global, JSProto_Iterator))
652 {
653 LeaveParseTaskZone(rt, parseTask);
654 return nullptr;
655 }
656
657 LeaveParseTaskZone(rt, parseTask);
658
659 // Point the prototypes of any objects in the script's compartment to refer
660 // to the corresponding prototype in the new compartment. This will briefly
661 // create cross compartment pointers, which will be fixed by the
662 // MergeCompartments call below.
663 for (gc::CellIter iter(parseTask->cx->zone(), gc::FINALIZE_TYPE_OBJECT);
664 !iter.done();
665 iter.next())
666 {
667 types::TypeObject *object = iter.get<types::TypeObject>();
668 TaggedProto proto(object->proto());
669 if (!proto.isObject())
670 continue;
671
672 JSProtoKey key = JS::IdentifyStandardPrototype(proto.toObject());
673 if (key == JSProto_Null)
674 continue;
675 JS_ASSERT(key == JSProto_Object || key == JSProto_Array ||
676 key == JSProto_Function || key == JSProto_RegExp ||
677 key == JSProto_Iterator);
678
679 JSObject *newProto = GetBuiltinPrototypePure(global, key);
680 JS_ASSERT(newProto);
681
682 object->setProtoUnchecked(newProto);
683 }
684
685 // Move the parsed script and all its contents into the desired compartment.
686 gc::MergeCompartments(parseTask->cx->compartment(), cx->compartment());
687 parseTask->finish();
688
689 RootedScript script(rt, parseTask->script);
690 assertSameCompartment(cx, script);
691
692 // Report any error or warnings generated during the parse, and inform the
693 // debugger about the compiled scripts.
694 for (size_t i = 0; i < parseTask->errors.length(); i++)
695 parseTask->errors[i]->throwError(cx);
696 if (parseTask->overRecursed)
697 js_ReportOverRecursed(cx);
698
699 if (script) {
700 // The Debugger only needs to be told about the topmost script that was compiled.
701 GlobalObject *compileAndGoGlobal = nullptr;
702 if (script->compileAndGo())
703 compileAndGoGlobal = &script->global();
704 Debugger::onNewScript(cx, script, compileAndGoGlobal);
705
706 // The NewScript hook needs to be called for all compiled scripts.
707 CallNewScriptHookForAllScripts(cx, script);
708 }
709
710 return script;
711 }
712
713 void
714 WorkerThread::destroy()
715 {
716 if (thread) {
717 {
718 AutoLockWorkerThreadState lock;
719 terminate = true;
720
721 /* Notify all workers, to ensure that this thread wakes up. */
722 WorkerThreadState().notifyAll(GlobalWorkerThreadState::PRODUCER);
723 }
724
725 PR_JoinThread(thread);
726 }
727
728 if (!threadData.empty())
729 threadData.destroy();
730 }
731
732 /* static */
733 void
734 WorkerThread::ThreadMain(void *arg)
735 {
736 PR_SetCurrentThreadName("Analysis Helper");
737 static_cast<WorkerThread *>(arg)->threadLoop();
738 }
739
740 void
741 WorkerThread::handleAsmJSWorkload()
742 {
743 #ifdef JS_ION
744 JS_ASSERT(WorkerThreadState().isLocked());
745 JS_ASSERT(WorkerThreadState().canStartAsmJSCompile());
746 JS_ASSERT(idle());
747
748 asmData = WorkerThreadState().asmJSWorklist().popCopy();
749 bool success = false;
750
751 do {
752 AutoUnlockWorkerThreadState unlock;
753 PerThreadData::AutoEnterRuntime enter(threadData.addr(), asmData->runtime);
754
755 jit::IonContext icx(asmData->mir->compartment->runtime(),
756 asmData->mir->compartment,
757 &asmData->mir->alloc());
758
759 int64_t before = PRMJ_Now();
760
761 if (!OptimizeMIR(asmData->mir))
762 break;
763
764 asmData->lir = GenerateLIR(asmData->mir);
765 if (!asmData->lir)
766 break;
767
768 int64_t after = PRMJ_Now();
769 asmData->compileTime = (after - before) / PRMJ_USEC_PER_MSEC;
770
771 success = true;
772 } while(0);
773
774 // On failure, signal parent for harvesting in CancelOutstandingJobs().
775 if (!success) {
776 WorkerThreadState().noteAsmJSFailure(asmData->func);
777 WorkerThreadState().notifyAll(GlobalWorkerThreadState::CONSUMER);
778 asmData = nullptr;
779 return;
780 }
781
782 // On success, move work to the finished list.
783 WorkerThreadState().asmJSFinishedList().append(asmData);
784 asmData = nullptr;
785
786 // Notify the main thread in case it's blocked waiting for a LifoAlloc.
787 WorkerThreadState().notifyAll(GlobalWorkerThreadState::CONSUMER);
788 #else
789 MOZ_CRASH();
790 #endif // JS_ION
791 }
792
793 void
794 WorkerThread::handleIonWorkload()
795 {
796 #ifdef JS_ION
797 JS_ASSERT(WorkerThreadState().isLocked());
798 JS_ASSERT(WorkerThreadState().canStartIonCompile());
799 JS_ASSERT(idle());
800
801 ionBuilder = WorkerThreadState().ionWorklist().popCopy();
802
803 TraceLogger *logger = TraceLoggerForCurrentThread();
804 AutoTraceLog logScript(logger, TraceLogCreateTextId(logger, ionBuilder->script()));
805 AutoTraceLog logCompile(logger, TraceLogger::IonCompilation);
806
807 JSRuntime *rt = ionBuilder->script()->compartment()->runtimeFromAnyThread();
808
809 {
810 AutoUnlockWorkerThreadState unlock;
811 PerThreadData::AutoEnterRuntime enter(threadData.addr(),
812 ionBuilder->script()->runtimeFromAnyThread());
813 jit::IonContext ictx(jit::CompileRuntime::get(rt),
814 jit::CompileCompartment::get(ionBuilder->script()->compartment()),
815 &ionBuilder->alloc());
816 ionBuilder->setBackgroundCodegen(jit::CompileBackEnd(ionBuilder));
817 }
818
819 FinishOffThreadIonCompile(ionBuilder);
820 ionBuilder = nullptr;
821
822 // Ping the main thread so that the compiled code can be incorporated
823 // at the next interrupt callback. Don't interrupt Ion code for this, as
824 // this incorporation can be delayed indefinitely without affecting
825 // performance as long as the main thread is actually executing Ion code.
826 rt->requestInterrupt(JSRuntime::RequestInterruptAnyThreadDontStopIon);
827
828 // Notify the main thread in case it is waiting for the compilation to finish.
829 WorkerThreadState().notifyAll(GlobalWorkerThreadState::CONSUMER);
830 #else
831 MOZ_CRASH();
832 #endif // JS_ION
833 }
834
835 void
836 ExclusiveContext::setWorkerThread(WorkerThread *workerThread)
837 {
838 workerThread_ = workerThread;
839 perThreadData = workerThread->threadData.addr();
840 }
841
842 frontend::CompileError &
843 ExclusiveContext::addPendingCompileError()
844 {
845 frontend::CompileError *error = js_new<frontend::CompileError>();
846 if (!error)
847 MOZ_CRASH();
848 if (!workerThread()->parseTask->errors.append(error))
849 MOZ_CRASH();
850 return *error;
851 }
852
853 void
854 ExclusiveContext::addPendingOverRecursed()
855 {
856 if (workerThread()->parseTask)
857 workerThread()->parseTask->overRecursed = true;
858 }
859
860 void
861 WorkerThread::handleParseWorkload()
862 {
863 JS_ASSERT(WorkerThreadState().isLocked());
864 JS_ASSERT(WorkerThreadState().canStartParseTask());
865 JS_ASSERT(idle());
866
867 parseTask = WorkerThreadState().parseWorklist().popCopy();
868 parseTask->cx->setWorkerThread(this);
869
870 {
871 AutoUnlockWorkerThreadState unlock;
872 PerThreadData::AutoEnterRuntime enter(threadData.addr(),
873 parseTask->exclusiveContextGlobal->runtimeFromAnyThread());
874 SourceBufferHolder srcBuf(parseTask->chars, parseTask->length,
875 SourceBufferHolder::NoOwnership);
876 parseTask->script = frontend::CompileScript(parseTask->cx, &parseTask->alloc,
877 NullPtr(), NullPtr(),
878 parseTask->options,
879 srcBuf);
880 }
881
882 // The callback is invoked while we are still off the main thread.
883 parseTask->callback(parseTask, parseTask->callbackData);
884
885 // FinishOffThreadScript will need to be called on the script to
886 // migrate it into the correct compartment.
887 WorkerThreadState().parseFinishedList().append(parseTask);
888
889 parseTask = nullptr;
890
891 // Notify the main thread in case it is waiting for the parse/emit to finish.
892 WorkerThreadState().notifyAll(GlobalWorkerThreadState::CONSUMER);
893 }
894
895 void
896 WorkerThread::handleCompressionWorkload()
897 {
898 JS_ASSERT(WorkerThreadState().isLocked());
899 JS_ASSERT(WorkerThreadState().canStartCompressionTask());
900 JS_ASSERT(idle());
901
902 compressionTask = WorkerThreadState().compressionWorklist().popCopy();
903 compressionTask->workerThread = this;
904
905 {
906 AutoUnlockWorkerThreadState unlock;
907 if (!compressionTask->work())
908 compressionTask->setOOM();
909 }
910
911 compressionTask->workerThread = nullptr;
912 compressionTask = nullptr;
913
914 // Notify the main thread in case it is waiting for the compression to finish.
915 WorkerThreadState().notifyAll(GlobalWorkerThreadState::CONSUMER);
916 }
917
918 bool
919 js::StartOffThreadCompression(ExclusiveContext *cx, SourceCompressionTask *task)
920 {
921 EnsureWorkerThreadsInitialized(cx);
922
923 AutoLockWorkerThreadState lock;
924
925 if (!WorkerThreadState().compressionWorklist().append(task))
926 return false;
927
928 WorkerThreadState().notifyOne(GlobalWorkerThreadState::PRODUCER);
929 return true;
930 }
931
932 bool
933 GlobalWorkerThreadState::compressionInProgress(SourceCompressionTask *task)
934 {
935 JS_ASSERT(isLocked());
936 for (size_t i = 0; i < compressionWorklist().length(); i++) {
937 if (compressionWorklist()[i] == task)
938 return true;
939 }
940 for (size_t i = 0; i < threadCount; i++) {
941 if (threads[i].compressionTask == task)
942 return true;
943 }
944 return false;
945 }
946
947 bool
948 SourceCompressionTask::complete()
949 {
950 JS_ASSERT_IF(!ss, !chars);
951 if (active()) {
952 AutoLockWorkerThreadState lock;
953
954 while (WorkerThreadState().compressionInProgress(this))
955 WorkerThreadState().wait(GlobalWorkerThreadState::CONSUMER);
956
957 ss->ready_ = true;
958
959 // Update memory accounting.
960 if (!oom)
961 cx->updateMallocCounter(ss->computedSizeOfData());
962
963 ss = nullptr;
964 chars = nullptr;
965 }
966 if (oom) {
967 js_ReportOutOfMemory(cx);
968 return false;
969 }
970 return true;
971 }
972
973 SourceCompressionTask *
974 GlobalWorkerThreadState::compressionTaskForSource(ScriptSource *ss)
975 {
976 JS_ASSERT(isLocked());
977 for (size_t i = 0; i < compressionWorklist().length(); i++) {
978 SourceCompressionTask *task = compressionWorklist()[i];
979 if (task->source() == ss)
980 return task;
981 }
982 for (size_t i = 0; i < threadCount; i++) {
983 SourceCompressionTask *task = threads[i].compressionTask;
984 if (task && task->source() == ss)
985 return task;
986 }
987 return nullptr;
988 }
989
990 const jschar *
991 ScriptSource::getOffThreadCompressionChars(ExclusiveContext *cx)
992 {
993 // If this is being compressed off thread, return its uncompressed chars.
994
995 if (ready()) {
996 // Compression has already finished on the source.
997 return nullptr;
998 }
999
1000 AutoLockWorkerThreadState lock;
1001
1002 // Look for a token that hasn't finished compressing and whose source is
1003 // the given ScriptSource.
1004 if (SourceCompressionTask *task = WorkerThreadState().compressionTaskForSource(this))
1005 return task->uncompressedChars();
1006
1007 // Compressing has finished, so this ScriptSource is ready. Avoid future
1008 // queries on the worker thread state when getting the chars.
1009 ready_ = true;
1010
1011 return nullptr;
1012 }
1013
1014 void
1015 WorkerThread::threadLoop()
1016 {
1017 JS::AutoAssertNoGC nogc;
1018 AutoLockWorkerThreadState lock;
1019
1020 js::TlsPerThreadData.set(threadData.addr());
1021
1022 // Compute the thread's stack limit, for over-recursed checks.
1023 uintptr_t stackLimit = GetNativeStackBase();
1024 #if JS_STACK_GROWTH_DIRECTION > 0
1025 stackLimit += WORKER_STACK_QUOTA;
1026 #else
1027 stackLimit -= WORKER_STACK_QUOTA;
1028 #endif
1029 for (size_t i = 0; i < ArrayLength(threadData.ref().nativeStackLimit); i++)
1030 threadData.ref().nativeStackLimit[i] = stackLimit;
1031
1032 while (true) {
1033 JS_ASSERT(!ionBuilder && !asmData);
1034
1035 // Block until a task is available.
1036 while (true) {
1037 if (terminate)
1038 return;
1039 if (WorkerThreadState().canStartIonCompile() ||
1040 WorkerThreadState().canStartAsmJSCompile() ||
1041 WorkerThreadState().canStartParseTask() ||
1042 WorkerThreadState().canStartCompressionTask())
1043 {
1044 break;
1045 }
1046 WorkerThreadState().wait(GlobalWorkerThreadState::PRODUCER);
1047 }
1048
1049 // Dispatch tasks, prioritizing AsmJS work.
1050 if (WorkerThreadState().canStartAsmJSCompile())
1051 handleAsmJSWorkload();
1052 else if (WorkerThreadState().canStartIonCompile())
1053 handleIonWorkload();
1054 else if (WorkerThreadState().canStartParseTask())
1055 handleParseWorkload();
1056 else if (WorkerThreadState().canStartCompressionTask())
1057 handleCompressionWorkload();
1058 else
1059 MOZ_ASSUME_UNREACHABLE("No task to perform");
1060 }
1061 }
1062
1063 #else /* JS_THREADSAFE */
1064
1065 using namespace js;
1066
1067 #ifdef JS_ION
1068
1069 bool
1070 js::StartOffThreadAsmJSCompile(ExclusiveContext *cx, AsmJSParallelTask *asmData)
1071 {
1072 MOZ_ASSUME_UNREACHABLE("Off thread compilation not available in non-THREADSAFE builds");
1073 }
1074
1075 bool
1076 js::StartOffThreadIonCompile(JSContext *cx, jit::IonBuilder *builder)
1077 {
1078 MOZ_ASSUME_UNREACHABLE("Off thread compilation not available in non-THREADSAFE builds");
1079 }
1080
1081 #endif // JS_ION
1082
1083 void
1084 js::CancelOffThreadIonCompile(JSCompartment *compartment, JSScript *script)
1085 {
1086 }
1087
1088 void
1089 js::CancelOffThreadParses(JSRuntime *rt)
1090 {
1091 }
1092
1093 bool
1094 js::StartOffThreadParseScript(JSContext *cx, const ReadOnlyCompileOptions &options,
1095 const jschar *chars, size_t length,
1096 JS::OffThreadCompileCallback callback, void *callbackData)
1097 {
1098 MOZ_ASSUME_UNREACHABLE("Off thread compilation not available in non-THREADSAFE builds");
1099 }
1100
1101 bool
1102 js::StartOffThreadCompression(ExclusiveContext *cx, SourceCompressionTask *task)
1103 {
1104 MOZ_ASSUME_UNREACHABLE("Off thread compression not available");
1105 }
1106
1107 bool
1108 SourceCompressionTask::complete()
1109 {
1110 JS_ASSERT(!active() && !oom);
1111 return true;
1112 }
1113
1114 const jschar *
1115 ScriptSource::getOffThreadCompressionChars(ExclusiveContext *cx)
1116 {
1117 JS_ASSERT(ready());
1118 return nullptr;
1119 }
1120
1121 frontend::CompileError &
1122 ExclusiveContext::addPendingCompileError()
1123 {
1124 MOZ_ASSUME_UNREACHABLE("Off thread compilation not available.");
1125 }
1126
1127 void
1128 ExclusiveContext::addPendingOverRecursed()
1129 {
1130 MOZ_ASSUME_UNREACHABLE("Off thread compilation not available.");
1131 }
1132
1133 #endif /* JS_THREADSAFE */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial