Limit size of first page based on serialized data.

src/api.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 "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 10 matching lines @@
 #include "src/base/utils/random-number-generator.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/conversions-inl.h"
 #include "src/counters.h"
 #include "src/cpu-profiler.h"
 #include "src/debug.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
-#include "src/full-codegen.h"
 #include "src/global-handles.h"
 #include "src/heap-profiler.h"
 #include "src/heap-snapshot-generator-inl.h"
 #include "src/icu_util.h"
 #include "src/json-parser.h"
 #include "src/messages.h"
 #include "src/natives.h"
 #include "src/parser.h"
 #include "src/profile-generator-inl.h"
 #include "src/property.h"
@@ skipping 173 matching lines @@
   if (try_catch.HasCaught()) return false;
   ScriptOrigin origin(String::NewFromUtf8(isolate, "<embedded script>"));
   ScriptCompiler::Source source(source_string, origin);
   Local<Script> script = ScriptCompiler::Compile(isolate, &source);
   if (try_catch.HasCaught()) return false;
   script->Run();
   return !try_catch.HasCaught();
 }
 
 
-void CheckDefaultReservationSizes(const i::StartupSerializer& startup_ser,
-                                  const i::PartialSerializer& context_ser) {
-#ifdef DEBUG
-  i::List<i::SerializedData::Reservation> startup_reservations;
-  i::List<i::SerializedData::Reservation> context_reservations;
-  startup_ser.EncodeReservations(&startup_reservations);
-  context_ser.EncodeReservations(&context_reservations);
-  for (int space = 0; space < i::Serializer::kNumberOfSpaces; space++) {
-    // Exactly one chunk per space.
-    CHECK(startup_reservations[space].is_last());
-    CHECK(startup_reservations[space].is_last());
-    uint32_t sum = startup_reservations[space].chunk_size() +
-                   context_reservations[space].chunk_size();
-    uint32_t limit = 0;
-    const int constant_pool_delta = i::FLAG_enable_ool_constant_pool ? 48 : 0;
-    switch (space) {
-      case i::NEW_SPACE:
-        limit = 3 * i::kPointerSize;
-        break;
-      case i::OLD_POINTER_SPACE:
-        limit = (128 + constant_pool_delta) * i::kPointerSize * i::KB;
-        break;
-      case i::OLD_DATA_SPACE:
-        limit = 192 * i::KB;
-        break;
-      case i::MAP_SPACE:
-        limit = 16 * i::kPointerSize * i::KB;
-        break;
-      case i::CELL_SPACE:
-        limit = 16 * i::kPointerSize * i::KB;
-        break;
-      case i::PROPERTY_CELL_SPACE:
-        limit = 8 * i::kPointerSize * i::KB;
-        break;
-      case i::CODE_SPACE:
-        limit = RoundUp((480 - constant_pool_delta) * i::KB *
-                            i::FullCodeGenerator::kBootCodeSizeMultiplier / 100,
-                        i::kPointerSize);
-        break;
-      default:
-        break;
-    }
-    CHECK_LE(sum, limit);
-  }
-#endif  // DEBUG
-}
-
-
 StartupData V8::CreateSnapshotDataBlob(char* custom_source) {
   Isolate::CreateParams params;
   params.enable_serializer = true;
   Isolate* isolate = v8::Isolate::New(params);
   StartupData result = {NULL, 0};
   {
     Isolate::Scope isolate_scope(isolate);
     i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
     Persistent<Context> context;
     i::Snapshot::Metadata metadata;
@@ skipping 23 matching lines @@
 
       i::SnapshotByteSink snapshot_sink;
       i::StartupSerializer ser(internal_isolate, &snapshot_sink);
       ser.SerializeStrongReferences();
 
       i::SnapshotByteSink context_sink;
       i::PartialSerializer context_ser(internal_isolate, &ser, &context_sink);
       context_ser.Serialize(&raw_context);
       ser.SerializeWeakReferences();
 
-      i::SnapshotData sd(snapshot_sink, ser);
-      i::SnapshotData csd(context_sink, context_ser);
-
-      if (custom_source == NULL) CheckDefaultReservationSizes(ser, context_ser);
-
-      result = i::Snapshot::CreateSnapshotBlob(sd.RawData(), csd.RawData(),
-                                               metadata);
+      result = i::Snapshot::CreateSnapshotBlob(ser, context_ser, metadata);
     }
   }
   isolate->Dispose();
   return result;
 }
 
 
 void V8::SetFlagsFromString(const char* str, int length) {
   i::FlagList::SetFlagsFromString(str, length);
 }
@@ skipping 7504 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal