Added isolate + thread high watermark tracking to Observatory

runtime/vm/zone.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 "vm/zone.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/handles_impl.h"
@@ skipping 26 matching lines @@
 
   static void Delete(Segment* segment) { free(segment); }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Segment);
 };
 
 
 void Zone::Segment::DeleteSegmentList(Segment* head) {
   Segment* current = head;
   while (current != NULL) {
+    if (Thread::Current() != NULL) {
+      Thread::Current()->DecrementThreadMemoryUsage(current->size());
+    }

[siva, 2016/12/27 22:09:26]

Please hoist Thread:Current() outside the loop into a local variable
instead of accessing thread local storage at every iteration of the loop.

Thread* thread = Thread::Current();
while (...)
  if (thread != NULL) {
    thread->Decrement....(...);
  }
  ....
}

When is Thread::Current() null? (is it just unit tests?)

[bkonyi, 2016/12/28 00:09:58]

Done.

There's a case when running the unit tests where it seems a zone is allocated
and not associated with a thread, so we get a segfault when we delete segments
from that zone.

[siva, 2016/12/28 17:52:35]

It can be Null when the native IO isolate is allocating memory, see
Dart_ScopeAllocate in dart_api_impl.cc

We need to account for this in a special category called native IO isolate, the
recent OOM issue that we ran into during the Fuchsia port was from this entity.

[bkonyi, 2016/12/28 19:00:49]

I've added a TODO to handle the special case when the native IO isolate in a
separate change. 

     Segment* next = current->next();
 #ifdef DEBUG
     // Zap the entire current segment (including the header).
     memset(current, kZapDeletedByte, current->size());
 #endif
     Segment::Delete(current);
     current = next;
   }
 }
 
 
 Zone::Segment* Zone::Segment::New(intptr_t size, Zone::Segment* next) {
   ASSERT(size >= 0);
   Segment* result = reinterpret_cast<Segment*>(malloc(size));
   if (result == NULL) {
     OUT_OF_MEMORY();
   }
   ASSERT(Utils::IsAligned(result->start(), Zone::kAlignment));
 #ifdef DEBUG
   // Zap the entire allocated segment (including the header).
   memset(result, kZapUninitializedByte, size);
 #endif
   result->next_ = next;
   result->size_ = size;
+  if (Thread::Current() != NULL) {
+    Thread::Current()->IncrementThreadMemoryUsage(size);
+  }
   return result;
 }
 
 
 Zone::Zone()
     : initial_buffer_(buffer_, kInitialChunkSize),
       position_(initial_buffer_.start()),
       limit_(initial_buffer_.end()),
       head_(NULL),
       large_segments_(NULL),
@@ skipping 222 matching lines @@
   ASSERT(thread()->zone() == &zone_);
   thread()->set_zone(zone_.previous_);
   if (FLAG_trace_zones) {
     OS::PrintErr("*** Deleting Stack zone 0x%" Px "(0x%" Px ")\n",
                  reinterpret_cast<intptr_t>(this),
                  reinterpret_cast<intptr_t>(&zone_));
   }
 }
 
 }  // namespace dart