Migrate NoSafepointScope; add constrained concurrent allocation to unit test

runtime/vm/thread_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/unit_test.h"
 #include "vm/profiler.h"
 #include "vm/thread_pool.h"
@@ skipping 111 matching lines @@
       StackZone stack_zone(thread);
       HANDLESCOPE(thread);
       Zone* zone = thread->zone();
       EXPECT_EQ(zone, stack_zone.GetZone());
       ZoneGrowableArray<bool>* a0 = new(zone) ZoneGrowableArray<bool>(zone, 1);
       GrowableArray<bool> a1(zone, 1);
       for (intptr_t i = 0; i < 100000; ++i) {
         a0->Add(true);
         a1.Add(true);
       }
-      // Check that we can create handles (but not yet allocate heap objects).
-      String& str = String::Handle(zone, foo_.raw());
-      EXPECT(str.Equals("foo"));
+      // Check that we can create handles and allocate in old space.
+      String& str = String::Handle(zone, String::New("old", Heap::kOld));
+      EXPECT(str.Equals("old"));
+
       const intptr_t unique_smi = id_ + 928327281;
       Smi& smi = Smi::Handle(zone, Smi::New(unique_smi));
       EXPECT(smi.Value() == unique_smi);
       ObjectCounter counter(isolate_, &smi);
       // Ensure that our particular zone is visited.
       // TODO(koda): Remove "->thread_registry()" after updating stack walker.
       isolate_->thread_registry()->VisitObjectPointers(&counter);
       EXPECT_EQ(1, counter.count());
+
+      char* unique_chars = zone->PrintToString("unique_str_%" Pd, id_);
+      String& unique_str = String::Handle(zone);
+      {
+        // String::New may create additional handles in the topmost scope that
+        // we don't want to count, so wrap this in its own scope.
+        HANDLESCOPE(thread);
+        unique_str = String::New(unique_chars, Heap::kOld);
+      }
+      EXPECT(unique_str.Equals(unique_chars));
+      ObjectCounter str_counter(isolate_, &unique_str);
+      // Ensure that our particular zone is visited.
+      // TODO(koda): Remove "->thread_registry()" after updating stack walker.
+      isolate_->thread_registry()->VisitObjectPointers(&str_counter);
+      // We should visit the string object exactly once.
+      EXPECT_EQ(1, str_counter.count());
     }
     Thread::ExitIsolateAsHelper();
     {
       MonitorLocker ml(monitor_);
       *done_ = true;
       ml.Notify();
     }
   }
 
  private:
   Isolate* isolate_;
   const String& foo_;
   Monitor* monitor_;
   bool* done_;
   intptr_t id_;
 };
 
 
 TEST_CASE(ManyTasksWithZones) {
   const int kTaskCount = 100;
   Monitor sync[kTaskCount];
   bool done[kTaskCount];
   Isolate* isolate = Thread::Current()->isolate();
   String& foo = String::Handle(String::New("foo"));
-
+  EXPECT(isolate->heap()->GrowthControlState());
+  isolate->heap()->DisableGrowthControl();
   for (int i = 0; i < kTaskCount; i++) {
     done[i] = false;
     Dart::thread_pool()->Run(
         new TaskWithZoneAllocation(isolate, foo, &sync[i], &done[i], i));
   }
   for (int i = 0; i < kTaskCount; i++) {
     // Check that main mutator thread can still freely use its own zone.
     String& bar = String::Handle(String::New("bar"));
     if (i % 10 == 0) {
       // Mutator thread is free to independently move in/out/between isolates.
@@ skipping 40 matching lines @@
   Thread::ExitIsolate();
   Thread::EnterIsolate(orig);
   // Original zone should be preserved.
   EXPECT_EQ(orig_zone, Thread::Current()->zone());
   EXPECT_STREQ("foo", orig_str);
   delete isos[0];
   delete isos[1];
 }
 
 }  // namespace dart