Partial fix for issue 173:...

src/zone.cc

 // Copyright 2006-2008 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 145 matching lines @@
   // there isn't enough room in the Zone to satisfy the request.
   ASSERT(size == RoundDown(size, kAlignment));
   ASSERT(position_ + size > limit_);
 
   // Compute the new segment size. We use a 'high water mark'
   // strategy, where we increase the segment size every time we expand
   // except that we employ a maximum segment size when we delete. This
   // is to avoid excessive malloc() and free() overhead.
   Segment* head = Segment::head();
   int old_size = (head == NULL) ? 0 : head->size();
-  int new_size = sizeof(Segment) + kAlignment + size + (old_size << 1);
-  if (new_size < kMinimumSegmentSize) new_size = kMinimumSegmentSize;
+  int segment_overhead = sizeof(Segment) + kAlignment;

[Kasper Lund, 2008/12/05 08:36:49]

This is a constant, right? Maybe make it 'static const int kSegmentOverhead'? 

[iposva, 2008/12/05 17:25:13]

Done.

+  int new_size = segment_overhead + size + (old_size << 1);
+  if (new_size < kMinimumSegmentSize) {
+    new_size = kMinimumSegmentSize;
+  } else if (new_size > kMaximumSegmentSize) {
+    // Limit the size of new segments to avoid growing the segment size
+    // exponentially, thus putting pressure on contiguous virtual address
+    // space.
+    if (size > (kMaximumSegmentSize - segment_overhead)) {
+      // Make sure to allocate a segment at least large enough to hold the
+      // requested size.
+      new_size = RoundUp(size + segment_overhead, kMinimumSegmentSize);

[Kasper Lund, 2008/12/05 08:36:49]

Why do you round the result up? If it's a feature to (maybe) leave some room in
the new segment, you may want to document that in a comment.

[iposva, 2008/12/05 17:25:13]

The idea was to round up to a size that is likely going to be a page size, but
since segments are allocated using malloc, this is mostly useless.

I removed the RoundUp() call.

On 2008/12/05 08:36:49, Kasper Lund wrote:

+    } else {
+      // Allocate a new segment of maximum size.
+      new_size = kMaximumSegmentSize;
+    }
+  }
   Segment* segment = Segment::New(new_size);
   if (segment == NULL) V8::FatalProcessOutOfMemory("Zone");
 
   // Recompute 'top' and 'limit' based on the new segment.
   Address result = RoundUp(segment->start(), kAlignment);
   position_ = result + size;
   limit_ = segment->end();
   ASSERT(position_ <= limit_);
   return result;
 }
 
 
 } }  // namespace v8::internal