Created methods to surface zone memory information for each isolate and thread in JSON.

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/safepoint.h"
@@ skipping 187 matching lines @@
     }
     EXPECT(done[i]);
     if (i % 10 == 0) {
       Thread::EnterIsolate(isolate);
     }
     EXPECT(bar.Equals("bar"));
   }
 }
 
 
+#ifndef PRODUCT
+class SimpleTaskWithZoneAllocation : public ThreadPool::Task {
+ public:
+  SimpleTaskWithZoneAllocation(intptr_t id,
+                               Isolate* isolate,
+                               Thread** thread_ptr,
+                               Monitor* sync,
+                               Monitor* monitor,
+                               intptr_t* done_count,
+                               bool* wait)
+      : id_(id),
+        isolate_(isolate),
+        thread_ptr_(thread_ptr),
+        sync_(sync),
+        monitor_(monitor),
+        done_count_(done_count),
+        wait_(wait) {}
+
+  virtual void Run() {
+    Thread::EnterIsolateAsHelper(isolate_, Thread::kUnknownTask);
+    {
+      Thread* thread = Thread::Current();
+      *thread_ptr_ = thread;
+      CreateStackZones(id_);
+    }
+    Thread::ExitIsolateAsHelper();
+    // Notify the main thread that this thread has exited.
+    {
+      MonitorLocker ml(monitor_);
+      *done_count_ += 1;
+      ml.Notify();
+    }
+  }
+
+ private:
+  void CreateStackZones(intptr_t num) {
+    Thread* thread = Thread::Current();
+    *thread_ptr_ = thread;
+
+    StackZone stack_zone(thread);
+    HANDLESCOPE(thread);
+    Zone* zone = thread->zone();
+    EXPECT_EQ(zone, stack_zone.GetZone());
+
+    // Create a zone (which is also a stack resource) and exercise it a bit.
+    ZoneGrowableArray<bool>* a0 = new (zone) ZoneGrowableArray<bool>(zone, 1);
+    GrowableArray<bool> a1(zone, 1);
+    for (intptr_t i = 0; i < 1000 * num + id_; ++i) {
+      a0->Add(true);
+      a1.Add(true);
+    }
+
+    num -= 1;
+    if (num != 0) {
+      CreateStackZones(num);
+      return;
+    }
+    {
+      // Let the main thread know we're done with memory ops on this thread.
+      MonitorLocker ml(monitor_);
+      *done_count_ += 1;
+      ml.Notify();
+    }
+    // Wait for the go-ahead from the main thread to exit.
+    {
+      MonitorLocker sync_ml(sync_);
+      while (*wait_) {
+        sync_ml.Wait();
+      }
+    }
+  }
+
+  intptr_t id_;
+  Isolate* isolate_;
+  Thread** thread_ptr_;
+  Monitor* sync_;
+  Monitor* monitor_;
+  intptr_t* done_count_;
+  bool* wait_;
+};
+
+
+TEST_CASE(ManySimpleTasksWithZones) {
+  const int kTaskCount = 10;
+  Monitor monitor;
+  Monitor sync;
+  Thread* threads[kTaskCount + 1];
+  Isolate* isolate = Thread::Current()->isolate();
+  intptr_t done_count = 0;
+  bool wait = true;
+  threads[kTaskCount] = Thread::Current();
+
+  EXPECT(isolate->heap()->GrowthControlState());
+  isolate->heap()->DisableGrowthControl();
+  for (intptr_t i = 0; i < kTaskCount; i++) {
+    Dart::thread_pool()->Run(new SimpleTaskWithZoneAllocation(
+        (i + 1), isolate, &threads[i], &sync, &monitor, &done_count, &wait));
+  }
+  // Wait until all spawned tasks finish their memory operations.
+  {
+    MonitorLocker ml(&monitor);
+    while (done_count < kTaskCount) {
+      ml.Wait();
+    }
+    // Reset the done counter for use later.
+    done_count = 0;
+  }
+
+  JSONStream stream;
+  Service::PrintJSONForVM(&stream, false);
+  const char* json = stream.ToCString();
+
+  // Confirm all expected entries are in the JSON output.
+  for (intptr_t i = 0; i < kTaskCount + 1; i++) {
+    Thread* thread = threads[i];
+    Isolate* thread_isolate = thread->isolate();
+    // Buffer can handle any possible input length given types.
+    char thread_address_buf[96];
+    char isolate_address_buf[64];

[siva, 2016/12/09 02:49:39]

Instead of using a local buffer with a number that might overflow if something
changes you could do the following:

set up :
Thread* current_thread = Thread::Current();
StackZone stack_zone(current_thread);
Zone* zone = current_thread->zone();

and replace the OS:;SNPrint with OS::SCreate...
char* zone_info_buf = OS::SCreate(zone, "\"type\" .....);

[bkonyi, 2016/12/09 17:52:57]

Done.

+    Zone* top_zone = thread->zone();
+
+    // Check that all zones are present with correct sizes.
+    while (top_zone != NULL) {
+      char zone_info_buf[96];
+      OS::SNPrint(zone_info_buf, sizeof(zone_info_buf),
+                  "\"type\":\"_Zone\","
+                  "\"capacity\":%ld,"
+                  "\"used\":%ld",
+                  top_zone->SizeInBytes(), top_zone->UsedSizeInBytes());
+
+      EXPECT_SUBSTRING(zone_info_buf, json);
+      top_zone = top_zone->previous();
+    }
+
+    // Check the thread exists and is the correct size.
+    OS::SNPrint(thread_address_buf, sizeof(thread_address_buf),
+                "\"type\":\"_Thread\","
+                "\"id\":\"threads\\/%" Pd64 "",
+                thread->os_thread()->trace_id());
+
+    // Ensure the isolate for each thread is valid.
+    OS::SNPrint(isolate_address_buf, sizeof(isolate_address_buf),
+                "\"type\":\"Isolate\","
+                "\"fixedId\":true,"
+                "\"id\":\"isolates\\/%" Pd64 "",
+                static_cast<int64_t>(thread_isolate->main_port()));
+
+    EXPECT_SUBSTRING(thread_address_buf, json);
+    EXPECT_SUBSTRING(isolate_address_buf, json);
+  }
+
+  // Unblock the tasks so they can finish.
+  {
+    MonitorLocker sync_ml(&sync);
+    wait = false;
+    sync_ml.NotifyAll();
+  }
+  // Now wait for them all to exit before destroying the isolate.
+  {
+    MonitorLocker ml(&monitor);
+    while (done_count < kTaskCount) {
+      ml.Wait();
+    }
+  }
+}
+#endif
+
+
 TEST_CASE(ThreadRegistry) {
   Isolate* orig = Thread::Current()->isolate();
   Zone* orig_zone = Thread::Current()->zone();
   char* orig_str = orig_zone->PrintToString("foo");
   Dart_ExitIsolate();
   // Create and enter a new isolate.
   Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
                      NULL);
   Zone* zone0 = Thread::Current()->zone();
   EXPECT(zone0 != orig_zone);
@@ skipping 407 matching lines @@
       TransitionVMToBlocked transition(thread);
       MonitorLocker ml(&done_monitor);
       if (done) {
         break;
       }
     }
   }
 }
 
 }  // namespace dart