Make AdjustAmountOfExternalAllocatedMemory() more robust.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 5257 matching lines @@
   i::Isolate* isolate = i::Isolate::Current();
   if (IsDeadCheck(isolate, "v8::V8::AddImplicitReferences()")) return;
   STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**));
   isolate->global_handles()->AddImplicitReferences(
       i::Handle<i::HeapObject>::cast(Utils::OpenHandle(*parent)).location(),
       reinterpret_cast<i::Object***>(children), length);
 }
 
 
 intptr_t V8::AdjustAmountOfExternalAllocatedMemory(intptr_t change_in_bytes) {
-  i::Isolate* isolate = i::Isolate::Current();
-  if (IsDeadCheck(isolate, "v8::V8::AdjustAmountOfExternalAllocatedMemory()")) {
+  i::Isolate* isolate = i::Isolate::UncheckedCurrent();
+  if (isolate == NULL || !isolate->IsInitialized() ||

[Erik Corry, 2012/08/07 07:32:13]

This seems a bit fragile.  If we are silently ignoring some updates then the
external memory count will become incorrect.  This will manifest itself as very
poor performance caused by too frequent GCs.  Perhaps it is better to let it
crash and fix whatever it is that is calling from the wrong thread?

[ulan, 2012/08/07 09:05:52]

It's tricky with all those transfers between threads. We want this function to
be a no-op if called from the wrong thread, otherwise we would have to add guard
in each thread:
if (is_v8_initialized()) AdjustAmountOfExternalAllocatedMemory();

At the moment GC is triggered based on the delta of externally allocated  memory
since the last GC (the absolute value of externally allocated memory doesn't
matter). So even if we occasionally miss some updates, this error won't spread
beyond one GC. Of course if we change our heuristics to depend on absolute value
of external memory then we will have a problem.

+      IsDeadCheck(isolate, "v8::V8::AdjustAmountOfExternalAllocatedMemory()")) {
     return 0;
   }
   return isolate->heap()->AdjustAmountOfExternalAllocatedMemory(
       change_in_bytes);
 }
 
 
 void V8::SetGlobalGCPrologueCallback(GCCallback callback) {
   i::Isolate* isolate = i::Isolate::Current();
   if (IsDeadCheck(isolate, "v8::V8::SetGlobalGCPrologueCallback()")) return;
@@ skipping 1231 matching lines @@
 
   v->VisitPointers(blocks_.first(), first_block_limit_);
 
   for (int i = 1; i < blocks_.length(); i++) {
     v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]);
   }
 }
 
 
 } }  // namespace v8::internal