Heap Snapshot maximum size limit is too low for really big apps.

src/profile-generator.cc

 // Copyright 2011 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 3393 matching lines @@
         v8::OutputStream::kAbort) aborted_ = true;
   }
 
   v8::OutputStream* stream_;
   int chunk_size_;
   ScopedVector<char> chunk_;
   int chunk_pos_;
   bool aborted_;
 };
 
+#if defined(V8_TARGET_ARCH_X64)
+const int HeapSnapshotJSONSerializer::kMaxSerializableSnapshotRawSize =
+    768 * MB;

[mnaganov (inactive), 2012/02/10 12:33:50]

I know a better place for this: SnapshotSizeConstants

+#else
 const int HeapSnapshotJSONSerializer::kMaxSerializableSnapshotRawSize =
     256 * MB;
+#endif
 
 void HeapSnapshotJSONSerializer::Serialize(v8::OutputStream* stream) {
   ASSERT(writer_ == NULL);
   writer_ = new OutputStreamWriter(stream);
 
   HeapSnapshot* original_snapshot = NULL;
   if (snapshot_->raw_entries_size() >= kMaxSerializableSnapshotRawSize) {
     // The snapshot is too big. Serialize a fake snapshot.
     original_snapshot = snapshot_;
-    snapshot_ = CreateFakeSnapshot();
+    snapshot_ = CreateFakeSnapshot(snapshot_->raw_entries_size());

[mnaganov (inactive), 2012/02/10 12:33:50]

Why can't CreateFakeSnapshot extract this value itself? It is already extracting
other fields from the snapshot.

   }
   // Since nodes graph is cyclic, we need the first pass to enumerate
   // them. Strings can be serialized in one pass.
   EnumerateNodes();
   SerializeImpl();
 
   delete writer_;
   writer_ = NULL;
 
   if (original_snapshot != NULL) {
     delete snapshot_;
     snapshot_ = original_snapshot;
   }
 }
 
 
-HeapSnapshot* HeapSnapshotJSONSerializer::CreateFakeSnapshot() {
+HeapSnapshot* HeapSnapshotJSONSerializer::CreateFakeSnapshot(
+    int raw_snapshot_size) {
   HeapSnapshot* result = new HeapSnapshot(snapshot_->collection(),
                                           HeapSnapshot::kFull,
                                           snapshot_->title(),
                                           snapshot_->uid());
   result->AllocateEntries(2, 1, 0);
   HeapEntry* root = result->AddRootEntry(1);
+  const char* text = snapshot_->collection()->names()->GetFormatted(
+      "The snapshot is too big. "
+      "Maximum snapshot size is %d MB. "
+      "Actual snapshot size is %d MB.",
+      kMaxSerializableSnapshotRawSize / MB,
+      (raw_snapshot_size + MB - 1) / MB);
   HeapEntry* message = result->AddEntry(
-      HeapEntry::kString, "The snapshot is too big", 0, 4, 0, 0);
+      HeapEntry::kString, text, 0, 4, 0, 0);
   root->SetUnidirElementReference(0, 1, message);
   result->SetDominatorsToSelf();
   return result;
 }
 
 
 void HeapSnapshotJSONSerializer::SerializeImpl() {
   writer_->AddCharacter('{');
   writer_->AddString("\"snapshot\":{");
   SerializeSnapshot();
@@ skipping 266 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal