fibers

Author: antonbashir

runtime/vm/flag_list.h

@@ -200,7 +200,7 @@ constexpr bool FLAG_support_il_printer = false;
   D(trace_optimization, bool, false, "Print optimization details.")            \
   R(trace_profiler, false, bool, false, "Profiler trace")                      \
   D(trace_profiler_verbose, bool, false, "Verbose profiler trace")             \
-  D(trace_runtime_calls, bool, false, "Trace runtime calls.")                  \
+  D(trace_runtime_calls, bool, true, "Trace runtime calls.")                  \
   R(trace_ssa_allocator, false, bool, false,                                   \
     "Trace register allocation over SSA.")                                     \
   P(trace_strong_mode_types, bool, false,                                      \

runtime/vm/heap/marker.cc

@@ -747,6 +747,7 @@ void GCMarker::ResetSlices() {
 }
 
 void GCMarker::IterateRoots(ObjectPointerVisitor* visitor) {
+  OS::Print("IterateRoots start\n");
   for (;;) {
     intptr_t slice = root_slices_started_.fetch_add(1);
     if (slice >= root_slices_count_) {
@@ -775,6 +776,7 @@ void GCMarker::IterateRoots(ObjectPointerVisitor* visitor) {
       ml.Notify();
     }
   }
+  OS::Print("IterateRoots end\n");
 }
 
 enum WeakSlices {

runtime/vm/heap/pages.cc

@@ -1067,7 +1067,9 @@ void PageSpace::CollectGarbageHelper(Thread* thread,
   // Abandon the remainder of the bump allocation block.
   ReleaseBumpAllocation();
 
+  OS::Print("MarkObjects start\n");
   marker_->MarkObjects(this);
+  OS::Print("MarkObjects end\n");
   usage_.used_in_words = marker_->marked_words() + allocated_black_in_words_;
   allocated_black_in_words_ = 0;
   mark_words_per_micro_ = marker_->MarkedWordsPerMicro();

runtime/vm/stack_frame.cc

@@ -212,7 +212,7 @@ void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   // helper functions to the raw object interface.
   NoSafepointScope no_safepoint;
   Code code;
-
+OS::Print("  pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp "\n", pc_, fp_, sp_);
   CompressedStackMaps::RawPayloadHandle maps;
   CompressedStackMaps::RawPayloadHandle global_table;
 
@@ -303,7 +303,6 @@ void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) {
     // to an osr function. In each of these cases, all stack slots contain
     // tagged pointers, so fall through.
 #if defined(DEBUG)
-    OS::Print("  pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp "\n", pc_, fp_, sp_);
     if (FLAG_precompiled_mode) {
       ASSERT(IsStubFrame());
     } else {
@@ -626,22 +625,26 @@ void StackFrameIterator::FrameSetIterator::Unpoison() {
 StackFrame* StackFrameIterator::FrameSetIterator::NextFrame(bool validate) {
   StackFrame* frame;
   ASSERT(HasNext());
+  if (StubCode::InCoroutineStub(stack_frame_.pc_)) {
+    frame = &stack_frame_;
+    frame->sp_ = sp_;
+    frame->fp_ = fp_;
+    frame->pc_ = pc_;
+    OS::Print("Coroutine stub frame\n");
+    OS::Print("  pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp "\n", pc_, fp_, sp_);
+    sp_ = frame->GetCallerSp();
+    fp_ = frame->GetCallerFp();
+    pc_ = frame->GetCallerPc();
+    Unpoison();
+    return NextFrame(validate);
+  }
   frame = &stack_frame_;
   frame->sp_ = sp_;
   frame->fp_ = fp_;
   frame->pc_ = pc_;
   sp_ = frame->GetCallerSp();
   fp_ = frame->GetCallerFp();
   pc_ = frame->GetCallerPc();
-  OS::Print("  pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp "\n", pc_, fp_, sp_);
-  StackFrame nframe{frame->thread()};
-  nframe.fp_ = fp_;
-  nframe.pc_ = pc_;
-  nframe.sp_ = sp_;
-  uword nsp_ = nframe.GetCallerSp();
-  uword nfp_ = nframe.GetCallerFp();
-  uword npc_ = nframe.GetCallerPc();
-  OS::Print("  pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp "\n", npc_, nfp_, nsp_);
   Unpoison();
   ASSERT(!validate || frame->IsValid());
   return frame;

runtime/vm/stub_code.cc

@@ -91,10 +91,9 @@ void StubCode::Init() {
 #undef STUB_CODE_GENERATE
 #undef STUB_CODE_SET_OBJECT_POOL
 
-CodePtr StubCode::Generate(
-    const char* name,
-    compiler::ObjectPoolBuilder* object_pool_builder,
-    void (compiler::StubCodeCompiler::* GenerateStub)()) {
+CodePtr StubCode::Generate(const char* name,
+                           compiler::ObjectPoolBuilder* object_pool_builder,
+                           void (compiler::StubCodeCompiler::*GenerateStub)()) {
   auto thread = Thread::Current();
   SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
@@ -144,6 +143,16 @@ bool StubCode::InJumpToFrameStub(uword pc) {
   return (pc >= entry) && (pc < (entry + size));
 }
 
+bool StubCode::InCoroutineStub(uword pc) {
+  ASSERT(HasBeenInitialized());
+  uword entry = StubCode::CoroutineInitialize().EntryPoint();
+  uword size = StubCode::CoroutineInitializeSize();
+  if ((pc >= entry) && (pc < (entry + size))) return true;
+  entry = StubCode::CoroutineFork().EntryPoint();
+  size = StubCode::CoroutineForkSize();
+  return ((pc >= entry) && (pc < (entry + size)));
+}
+
 #if !defined(DART_PRECOMPILED_RUNTIME)
 ArrayPtr compiler::StubCodeCompiler::BuildStaticCallsTable(
     Zone* zone,

runtime/vm/stub_code.h

@@ -51,6 +51,8 @@ class StubCode : public AllStatic {
 
   // Check if the specified pc is in the jump to frame stub.
   static bool InJumpToFrameStub(uword pc);
+  
+  static bool InCoroutineStub(uword pc);
 
   // Returns nullptr if no stub found.
   static const char* NameOfStub(uword entry_point);

runtime/vm/thread.cc

@@ -841,13 +841,17 @@ ErrorPtr Thread::HandleInterrupts() {
       // occur that does promote them.
       heap()->CollectGarbage(this, GCType::kEvacuate, GCReason::kStoreBuffer);
     }
+    OS::Print("After CollectGarbage\n");
     heap()->CheckFinalizeMarking(this);
+    OS::Print("After CheckFinalizeMarking\n");
 
 #if !defined(PRODUCT)
     if (isolate()->TakeHasCompletedBlocks()) {
       Profiler::ProcessCompletedBlocks(isolate());
     }
 #endif  // !defined(PRODUCT)
+  
+  OS::Print("After ProcessCompletedBlocks");
 
 #if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
     HeapProfileSampler& sampler = heap_sampler();
@@ -1100,6 +1104,8 @@ void Thread::VisitObjectPointers(ObjectPointerVisitor* visitor,
     const StackFrameIterator::CrossThreadPolicy cross_thread_policy =
         StackFrameIterator::kAllowCrossThreadIteration;
 
+    OS::Print("Thread::VisitObjectPointers\n");
+
     // Iterate over all the stack frames and visit objects on the stack.
     StackFrameIterator frames_iterator(top_exit_frame_info(), validation_policy,
                                        this, cross_thread_policy);
@@ -1114,6 +1120,8 @@ void Thread::VisitObjectPointers(ObjectPointerVisitor* visitor,
     // We are not on the mutator thread.
     RELEASE_ASSERT(top_exit_frame_info() == 0);
   }
+
+  OS::Print("Thread::VisitObjectPointers end\n");
 }
 
 class RestoreWriteBarrierInvariantVisitor : public ObjectPointerVisitor {