Revision: 21912
Author:   [email protected]
Date:     Mon Jun 23 08:37:46 2014 UTC
Log:      Version 3.26.31.7 (merged r21869, r21873)

Do GC if CodeRange fails to allocate a block.

Reduce number of writes to DependentCode array when inserting dependent IC.

BUG=305878
LOG=N
[email protected]

Review URL: https://codereview.chromium.org/349953002
http://code.google.com/p/v8/source/detail?r=21912

Modified:
 /branches/3.26/src/objects.cc
 /branches/3.26/src/spaces.cc
 /branches/3.26/src/spaces.h
 /branches/3.26/src/version.cc

=======================================
--- /branches/3.26/src/objects.cc       Wed Jun 11 07:07:52 2014 UTC
+++ /branches/3.26/src/objects.cc       Mon Jun 23 08:37:46 2014 UTC
@@ -12367,8 +12367,17 @@
   DisallowHeapAllocation no_heap_allocation;
   GroupStartIndexes starts(this);
   int i = starts.at(kWeakICGroup);
-  stub->set_next_code_link(object_at(i));
-  set_object_at(i, *stub);
+  Object* head = object_at(i);
+ // Try to insert the stub after the head of the list to minimize number of + // writes to the DependentCode array, since a write to the array can make it
+  // strong if it was alread marked by incremental marker.
+  if (head->IsCode()) {
+    stub->set_next_code_link(Code::cast(head)->next_code_link());
+    Code::cast(head)->set_next_code_link(*stub);
+  } else {
+    stub->set_next_code_link(head);
+    set_object_at(i, *stub);
+  }
 }


=======================================
--- /branches/3.26/src/spaces.cc        Thu May  1 00:05:11 2014 UTC
+++ /branches/3.26/src/spaces.cc        Mon Jun 23 08:37:46 2014 UTC
@@ -156,12 +156,12 @@
 }


-void CodeRange::GetNextAllocationBlock(size_t requested) {
+bool CodeRange::GetNextAllocationBlock(size_t requested) {
   for (current_allocation_block_index_++;
        current_allocation_block_index_ < allocation_list_.length();
        current_allocation_block_index_++) {
if (requested <= allocation_list_[current_allocation_block_index_].size) {
-      return;  // Found a large enough allocation block.
+      return true;  // Found a large enough allocation block.
     }
   }

@@ -188,12 +188,12 @@
        current_allocation_block_index_ < allocation_list_.length();
        current_allocation_block_index_++) {
if (requested <= allocation_list_[current_allocation_block_index_].size) {
-      return;  // Found a large enough allocation block.
+      return true;  // Found a large enough allocation block.
     }
   }

   // Code range is full or too fragmented.
-  V8::FatalProcessOutOfMemory("CodeRange::GetNextAllocationBlock");
+  return false;
 }


@@ -203,9 +203,8 @@
   ASSERT(commit_size <= requested_size);
   ASSERT(current_allocation_block_index_ < allocation_list_.length());
if (requested_size > allocation_list_[current_allocation_block_index_].size) {
-    // Find an allocation block large enough.  This function call may
- // call V8::FatalProcessOutOfMemory if it cannot find a large enough block.
-    GetNextAllocationBlock(requested_size);
+    // Find an allocation block large enough.
+    if (!GetNextAllocationBlock(requested_size)) return NULL;
   }
// Commit the requested memory at the start of the current allocation block. size_t aligned_requested = RoundUp(requested_size, MemoryChunk::kAlignment);
@@ -228,7 +227,8 @@
   allocation_list_[current_allocation_block_index_].start += *allocated;
   allocation_list_[current_allocation_block_index_].size -= *allocated;
   if (*allocated == current.size) {
-    GetNextAllocationBlock(0);  // This block is used up, get the next one.
+    // This block is used up, get the next one.
+    if (!GetNextAllocationBlock(0)) return NULL;
   }
   return current.start;
 }
=======================================
--- /branches/3.26/src/spaces.h Thu May  1 00:05:11 2014 UTC
+++ /branches/3.26/src/spaces.h Mon Jun 23 08:37:46 2014 UTC
@@ -985,8 +985,8 @@
   // Finds a block on the allocation list that contains at least the
   // requested amount of memory.  If none is found, sorts and merges
   // the existing free memory blocks, and searches again.
-  // If none can be found, terminates V8 with FatalProcessOutOfMemory.
-  void GetNextAllocationBlock(size_t requested);
+  // If none can be found, returns false.
+  bool GetNextAllocationBlock(size_t requested);
   // Compares the start addresses of two free blocks.
   static int CompareFreeBlockAddress(const FreeBlock* left,
                                      const FreeBlock* right);
=======================================
--- /branches/3.26/src/version.cc       Tue Jun 17 04:40:51 2014 UTC
+++ /branches/3.26/src/version.cc       Mon Jun 23 08:37:46 2014 UTC
@@ -35,7 +35,7 @@
 #define MAJOR_VERSION     3
 #define MINOR_VERSION     26
 #define BUILD_NUMBER      31
-#define PATCH_LEVEL       6
+#define PATCH_LEVEL       7
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
 #define IS_CANDIDATE_VERSION 0

--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
--- You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
For more options, visit https://groups.google.com/d/optout.

Reply via email to