Merge pull request 'fibers' (dart-lang#22) from fibers into main

Reviewed-on: http://git.local/dependencies/dart/pulls/22

Author: antonbashir

build-fiber-stress.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -e
+
+dart compile aot-snapshot --enable-asserts runtime/tests/vm/dart/fiber/fiber_stress.dart

build-fiber-test.sh

@@ -2,4 +2,4 @@
 
 set -e
 
-dart --enable_mirrors=true compile aot-snapshot   runtime/tests/vm/dart/fiber/fiber_test.dart
+dart compile aot-snapshot --enable-asserts runtime/tests/vm/dart/fiber/fiber_test.dart

runtime/tests/vm/dart/fiber/fiber_state_suite.dart

@@ -3,17 +3,80 @@ import 'package:expect/expect.dart';
 
 final tests = [
   testRegistry,
-  testStateLink,
   testProcessor,
-  testInvariant,
 ];
 
 void testRegistry() {
   Fiber.launch(() => Expect.equals(2, Fiber.registry.length));
+  Expect.equals(0, Fiber.registry.length);
+
+  Fiber.launch(() {
+    for (var i = 0; i < 32; i++) {
+      Fiber.spawn(Fiber.reschedule);
+    }
+    Expect.equals(2 + 32, Fiber.registry.length);
+
+    var index = 0;
+    for (var fiber in Fiber.registry) {
+      Expect.equals(fiber.index, index);
+      index++;
+    }
+  });
+  Expect.equals(0, Fiber.registry.length);
+
+  Fiber.launch(() {
+    for (var i = 0; i < 65; i++) {
+      Fiber.spawn(Fiber.reschedule);
+    }
+    final currentHash = Fiber.registry.hashCode;
+    for (var i = 0; i < 65; i++) {
+      Fiber.reschedule();
+    }
+    Expect.notEquals(currentHash, Fiber.registry.hashCode);
+  });
 }
 
-void testStateLink() {}
+void testProcessor() {
+  Expect.isTrue(Fiber.launch(() {}).state.disposed);
+  Expect.isTrue(Fiber.launch(() => Fiber.spawn(Fiber.reschedule)).state.disposed);
+
+  Expect.throws<StateError>(
+    () => Fiber.launch(() => Fiber.spawn(Fiber.suspend), idle: () {}),
+    (error) => error.message == "There are no scheduled fibers after idle",
+  );
 
-void testProcessor() {}
+  Fiber.launch(() {
+    final fibers = <Fiber, int>{};
+    var next = 0;
+    fibers[Fiber.child(() {
+      Fiber.reschedule();
+      Expect.equals(next++, fibers[Fiber.current]);
+    })] = 0;
+    fibers[Fiber.child(() {
+      Fiber.reschedule();
+      Expect.equals(next++, fibers[Fiber.current]);
+    })] = 1;
+    fibers[Fiber.child(() {
+      Fiber.reschedule();
+      Expect.equals(next++, fibers[Fiber.current]);
+    })] = 2;
+    fibers[Fiber.child(() {
+      Fiber.reschedule();
+      Expect.equals(next++, fibers[Fiber.current]);
+    })] = 3;
+    fibers[Fiber.child(() {
+      Fiber.reschedule();
+      Expect.equals(next++, fibers[Fiber.current]);
+    })] = 4;
 
-void testInvariant() {}
+    fibers.forEach((fiber, value) => Fiber.fork(fiber));
+
+    Fiber.suspend();
+    Fiber.suspend();
+    Fiber.suspend();
+    Fiber.suspend();
+    Fiber.suspend();
+
+    Expect.equals(5, next);
+  });
+}

runtime/tests/vm/dart/fiber/fiber_stress.dart

@@ -0,0 +1,48 @@
+import 'dart:fiber';
+import 'dart:typed_data';
+
+void main() {
+  Fiber.launch(() {
+    final iterations = 100000;
+    final delta = iterations * 0.1;
+    var percents = 0;
+    for (var i = 0; i < iterations; i++) {
+      print(i.toString());
+      Fiber.spawn(work1);
+      Fiber.spawn(work1);
+      Fiber.spawn(work1);
+      
+      Fiber.reschedule();
+      Fiber.reschedule();
+      Fiber.reschedule();
+    }
+    print("exit");
+  });
+}
+
+@pragma("vm:never-inline")
+void work1() {
+  Fiber.reschedule();
+  work2();
+  Fiber.spawn(work2);
+}
+
+@pragma("vm:never-inline")
+void work2() {
+  work3();
+}
+
+@pragma("vm:never-inline")
+void work3() {
+  work4();
+}
+
+@pragma("vm:never-inline")
+void work4() {
+  work5();
+}
+
+@pragma("vm:never-inline")
+void work5() {
+  Uint8List.new(1 * 1024 * 1024);
+}

runtime/tests/vm/dart/fiber/fiber_stress_suite.dart

@@ -1,3 +1,5 @@
+// VMOptions=--coroutines_registry_shrink_capacity=64
+
 import 'dart:fiber';
 import 'dart:async';
 import 'package:expect/expect.dart';
@@ -16,7 +18,7 @@ final suites = {
   "flow": flow.tests,
   "exceptions": exceptions.tests,
 };
-
+ 
 void main(List<String> arguments) {
   if (arguments.isEmpty) {
     for (var suite in suites.entries) {
@@ -36,7 +38,7 @@ void main(List<String> arguments) {
   print("Processing suite: ${arguments[0]}");
   for (var test in suite!) {
     final function = RegExp(r"Function 'test(.+)'").firstMatch(test.toString())!.group(1);
-    if (arguments.length == 2 || function == arguments[1].toLowerCase()) {
+    if (arguments.length == 1 || function!.toLowerCase() == arguments[1].toLowerCase()) {
       print("Processing test: test${function}");
       test();
       print("Test: test${function} finished");

runtime/tests/vm/dart/fiber/fiber_test.dart

@@ -8600,43 +8600,9 @@ LocationSummary* CoroutineTransferInstr::MakeLocationSummary(Zone* zone,
 }
 
 void CoroutineTransferInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const Register kFromCoroutine = CoroutineTransferABI::kFromCoroutineReg;
-  const Register kToCoroutine = CoroutineTransferABI::kToCoroutineReg;
-  const Register kToStackLimit = CoroutineTransferABI::kToStackLimitReg;
-
-#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
-  SPILLS_LR_TO_FRAME({});
-#endif
-  __ LoadFieldFromOffset(TMP, kFromCoroutine, Coroutine::attributes_offset());
-  __ AndImmediate(TMP, ~Coroutine::CoroutineAttributes::running);
-  __ OrImmediate(TMP, Coroutine::CoroutineAttributes::suspended);
-  __ StoreFieldToOffset(TMP, kFromCoroutine, Coroutine::attributes_offset());
-
-  __ LoadFieldFromOffset(TMP, kToCoroutine, Coroutine::attributes_offset());
-  __ AndImmediate(TMP, ~Coroutine::CoroutineAttributes::suspended);
-  __ OrImmediate(TMP, Coroutine::CoroutineAttributes::running);
-  __ StoreFieldToOffset(TMP, kToCoroutine, Coroutine::attributes_offset());
-
-  __ PushRegister(FPREG);
-  __ StoreFieldToOffset(SPREG, kFromCoroutine, Coroutine::stack_base_offset());
-
-  __ LoadFieldFromOffset(SPREG, kToCoroutine, Coroutine::stack_base_offset());
-  __ PopRegister(FPREG);
-  if (!FLAG_precompiled_mode) __ RestoreCodePointer();
-  if (FLAG_precompiled_mode)
-    __ movq(PP, compiler::Address(THR, Thread::global_object_pool_offset()));
-
-  __ LoadFieldFromOffset(kToStackLimit, kToCoroutine,
-                         Coroutine::overflow_stack_limit_offset());
-  __ StoreToOffset(kToCoroutine, THR, Thread::coroutine_offset());
-  __ StoreToOffset(kToStackLimit, THR, Thread::saved_stack_limit_offset());
-
-  compiler::Label scheduled_interrupts;
-  __ LoadFromOffset(TMP, THR, Thread::stack_limit_offset());
-  __ testq(TMP, compiler::Immediate(Thread::kInterruptsMask));
-  __ BranchIf(ZERO, &scheduled_interrupts);
-  __ StoreToOffset(kToStackLimit, THR, Thread::stack_limit_offset());
-  __ Bind(&scheduled_interrupts);
+  compiler->GenerateStubCall(source(), StubCode::CoroutineTransfer(),
+                             UntaggedPcDescriptors::kOther, locs(), deopt_id(),
+                             env());
 }
 
 Definition* SuspendInstr::Canonicalize(FlowGraph* flow_graph) {

runtime/vm/compiler/backend/il.cc

@@ -92,6 +92,7 @@ class ParsedFunction;
   V(Coroutine, UntaggedCoroutine, processor, Dynamic, VAR)                    \
   V(Coroutine, UntaggedCoroutine, to_processor_next, Dynamic, VAR)            \
   V(Coroutine, UntaggedCoroutine, to_processor_previous, Dynamic, VAR)        \
+  V(Coroutine, UntaggedCoroutine, to_state, Dynamic, VAR)                     \
   V(Coroutine, UntaggedCoroutine, caller, Coroutine, VAR)                     \
   V(Coroutine, UntaggedCoroutine, scheduler, Coroutine, VAR)                  \
   V(Coroutine, UntaggedCoroutine, argument, Dynamic, VAR)