Make regress-crbug-514081 less flaky by having max serialization size

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 2378 matching lines @@
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--enable-tracing") == 0) {
       options.trace_enabled = true;
       argv[i] = NULL;
     } else if (strncmp(argv[i], "--trace-config=", 15) == 0) {
       options.trace_config = argv[i] + 15;
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--enable-inspector") == 0) {
       options.enable_inspector = true;
       argv[i] = NULL;
+    } else if (strncmp(argv[i], "--max-serializer-memory-usage=", 30) == 0) {
+      options.max_serializer_memory_usage = atoi(argv[i] + 30);
+      argv[i] = NULL;
     }
   }
 
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
 
   // Set up isolated source groups.
   options.isolate_sources = new SourceGroup[options.num_isolates];
   SourceGroup* current = options.isolate_sources;
   current->Begin(argv, 1);
   for (int i = 1; i < argc; i++) {
@@ skipping 74 matching lines @@
 void Shell::EmptyMessageQueues(Isolate* isolate) {
   if (!i::FLAG_verify_predictable) {
     while (v8::platform::PumpMessageLoop(g_platform, isolate)) continue;
     v8::platform::RunIdleTasks(g_platform, isolate,
                                50.0 / base::Time::kMillisecondsPerSecond);
   }
 }
 
 class Serializer : public ValueSerializer::Delegate {
  public:
-  explicit Serializer(Isolate* isolate)
-      : isolate_(isolate), serializer_(isolate, this) {}
+  Serializer(Isolate* isolate, size_t max_memory_usage)
+      : isolate_(isolate),
+        serializer_(isolate, this),
+        max_memory_usage_(max_memory_usage),
+        current_memory_usage_(0) {}
 
   Maybe<bool> WriteValue(Local<Context> context, Local<Value> value,
                          Local<Value> transfer) {
     bool ok;
     DCHECK(!data_);
     data_.reset(new SerializationData);
     if (!PrepareTransfer(context, transfer).To(&ok)) {
       return Nothing<bool>();
     }
     serializer_.WriteHeader();
@@ skipping 30 matching lines @@
       }
     }
 
     size_t index = shared_array_buffers_.size();
     shared_array_buffers_.emplace_back(isolate_, shared_array_buffer);
     return Just<uint32_t>(static_cast<uint32_t>(index));
   }
 
   void* ReallocateBufferMemory(void* old_buffer, size_t size,
                                size_t* actual_size) override {
+    current_memory_usage_ += size;

[Michael Achenbach, 2017/02/15 09:35:24]

You could nest the addition within a condition about max_memory_usage_ != 0 as
well as it otherwise plays no roll.

I assume this might be ok for the purpose of testing and there's no place were
current_memory_usage_ is reduced?

[binji, 2017/02/15 20:31:55]

Right, I added a comment about that.

+    if (max_memory_usage_ != 0 && current_memory_usage_ > max_memory_usage_)
+      return nullptr;
+
     void* result = realloc(old_buffer, size);
     *actual_size = result ? size : 0;
     return result;
   }
 
   void FreeBufferMemory(void* buffer) override { free(buffer); }
 
  private:
   Maybe<bool> PrepareTransfer(Local<Context> context, Local<Value> transfer) {
     if (transfer->IsArray()) {
@@ skipping 57 matching lines @@
     }
 
     return Just(true);
   }
 
   Isolate* isolate_;
   ValueSerializer serializer_;
   std::unique_ptr<SerializationData> data_;
   std::vector<Global<ArrayBuffer>> array_buffers_;
   std::vector<Global<SharedArrayBuffer>> shared_array_buffers_;
+  size_t max_memory_usage_; /* For testing when memory exhaustion. */

[Michael Achenbach, 2017/02/15 09:35:24]

nit: remove "when"?

[binji, 2017/02/15 20:31:55]

Done.

+  size_t current_memory_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(Serializer);
 };
 
 class Deserializer : public ValueDeserializer::Delegate {
  public:
   Deserializer(Isolate* isolate, std::unique_ptr<SerializationData> data)
       : isolate_(isolate),
         deserializer_(isolate, data->data(), data->size(), this),
         data_(std::move(data)) {
@@ skipping 28 matching lines @@
   ValueDeserializer deserializer_;
   std::unique_ptr<SerializationData> data_;
 
   DISALLOW_COPY_AND_ASSIGN(Deserializer);
 };
 
 std::unique_ptr<SerializationData> Shell::SerializeValue(
     Isolate* isolate, Local<Value> value, Local<Value> transfer) {
   bool ok;
   Local<Context> context = isolate->GetCurrentContext();
-  Serializer serializer(isolate);
+  Serializer serializer(isolate, options.max_serializer_memory_usage);
   if (serializer.WriteValue(context, value, transfer).To(&ok)) {
     std::unique_ptr<SerializationData> data = serializer.Release();
     base::LockGuard<base::Mutex> lock_guard(workers_mutex_.Pointer());
     data->AppendExternalizedContentsTo(&externalized_contents_);
     return data;
   }
   return nullptr;
 }
 
 MaybeLocal<Value> Shell::DeserializeValue(
@@ skipping 247 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif