Add methods to enable configuration of ResourceConstraints based on limits derived at runtime.

src/heap.cc

 // Copyright 2012 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 47 matching lines @@
 #endif
 #if V8_TARGET_ARCH_MIPS && !V8_INTERPRETED_REGEXP
 #include "regexp-macro-assembler.h"
 #include "mips/regexp-macro-assembler-mips.h"
 #endif
 
 namespace v8 {
 namespace internal {
 
 
+// semispace_size_ should be a power of 2 and old_generation_size_ should be
+// a multiple of Page::kPageSize.
+#if V8_TARGET_ARCH_X64
+#define LUMP_OF_MEMORY (2 * MB)
+#else
+#define LUMP_OF_MEMORY MB
+#endif
+#if defined(ANDROID) || V8_TARGET_ARCH_MIPS

[Hannes Payer (out of office), 2013/09/19 14:50:57]

I never liked the ifdef here. Now it's time to get rid of it while you are
there. It would be great if the embedder (chrome, d8) would set the right
values. It also shouldn't be a binary decision. We have beefier and weaker
phones. Their could be arbitrary size values, depending on the device. WDYT?

[rmcilroy, 2013/09/19 15:01:34]

I don't like this ifdef particularly either, but I don't think forcing the
embedder to do this is the right way to do this.  The embedder doesn't
necessarily know what a good set of defaults are for different devices, and it
would just end up moving a single set of per-arch constants to sets of constants
in every single embedder, which are then just going to diverge and cause
unexpected performance differences as they diverge.  If the embedder really
knows what it wants these to be it can still override them using SetResources,
but I think it's good to have sensible defaults in here.

[Hannes Payer (out of office), 2013/09/19 16:25:28]

Well, what I mean is that we should have these ifdefs in chromium and in d8.
Right now we have Android/MIPS or others, X64 or others, and on top of that
resource constrained. We should keep X64 ifdef since this one is a true global
mode for v8. But apart from that we have 3 classes of devices right now:
- large memory device
- regular memory device
- low memory device
It would be actually awesome if the embedder would set arbitrary memory sizes,
based on the system state. But this is future work.

[rmcilroy, 2013/09/19 19:46:11]

There are more V8 embedders than just d8 and chrome, and I really don't agree
that it's cleaner to move from having one ifdef here to multiple ifdefs across
all the embedders.  Embedders shouldn't be forced to know what a reasonable size
for the semispace/oldspace/etc is or what the relationship between them is.

I do agree that we should reach a state where the embedder gives us a value for
how much memory is available (whether that's a signal for this being a
large/medium/low mem device, or is the actual available memory), and then V8
decides how to size these spaces based on this, but that's future work because
(i) currently Chrome doesn't even call SetResourceConstraints on V8 for the main
thread (I have a CL in the work to change this for the is_memory_constrained
flag), and (ii) due to the default isolate there is no particularly clear point
for the embedder to actually send this value and ensure that the heap is
configured correctly before it is setup.

+#define DEFAULT_SEMISPACE_MAX_SIZE (4 * Max(LUMP_OF_MEMORY, Page::kPageSize))
+#define DEFAULT_OLD_GENERATION_MAX_SIZE (192*MB)
+#define DEFAULT_EXECUTABLE_MAX_SIZE (192*MB)
+#else
+#define DEFAULT_SEMISPACE_MAX_SIZE (8 * Max(LUMP_OF_MEMORY, Page::kPageSize))
+#define DEFAULT_OLD_GENERATION_MAX_SIZE (700ul * LUMP_OF_MEMORY)
+#define DEFAULT_EXECUTABLE_MAX_SIZE (256l * LUMP_OF_MEMORY)
+#endif
+
+
 Heap::Heap()
     : isolate_(NULL),
-// semispace_size_ should be a power of 2 and old_generation_size_ should be
-// a multiple of Page::kPageSize.
 #if V8_TARGET_ARCH_X64
-#define LUMP_OF_MEMORY (2 * MB)
       code_range_size_(512*MB),
 #else
-#define LUMP_OF_MEMORY MB
       code_range_size_(0),
 #endif
-#if defined(ANDROID) || V8_TARGET_ARCH_MIPS
-      reserved_semispace_size_(4 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
-      max_semispace_size_(4 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
+      reserved_semispace_size_(DEFAULT_SEMISPACE_MAX_SIZE),

[Hannes Payer (out of office), 2013/09/19 14:50:57]

Here we could set the values to proper default values, like our default values
for non-mobile devices now.

[rmcilroy, 2013/09/19 15:01:34]

I'm not sure what you mean here?

[Hannes Payer (out of office), 2013/09/19 16:25:28]

What I meant is to set the values to
reserved_semispace_size_(8 * Max(LUMP_OF_MEMORY, Page::kPageSize)),	
max_semispace_size_(8 * Max(LUMP_OF_MEMORY, Page::kPageSize)),	
initial_semispace_size_(Page::kPageSize),	
max_old_generation_size_(700ul * LUMP_OF_MEMORY),	
max_executable_size_(256l * LUMP_OF_MEMORY),

[rmcilroy, 2013/09/19 19:46:11]

Maybe we could just set these all to zero initially, and do the default setting
in ConfigureHeap (which should be called from ConfigureDefaultHeap even if the
embedder doesn't call SetResourceConstraints). WDYT?

+      max_semispace_size_(DEFAULT_SEMISPACE_MAX_SIZE),
       initial_semispace_size_(Page::kPageSize),
-      max_old_generation_size_(192*MB),
-      max_executable_size_(max_old_generation_size_),
-#else
-      reserved_semispace_size_(8 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
-      max_semispace_size_(8 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
-      initial_semispace_size_(Page::kPageSize),
-      max_old_generation_size_(700ul * LUMP_OF_MEMORY),
-      max_executable_size_(256l * LUMP_OF_MEMORY),
-#endif
-
+      max_old_generation_size_(DEFAULT_OLD_GENERATION_MAX_SIZE),
+      max_executable_size_(DEFAULT_EXECUTABLE_MAX_SIZE),
 // Variables set based on semispace_size_ and old_generation_size_ in
 // ConfigureHeap (survived_since_last_expansion_, external_allocation_limit_)
 // Will be 4 * reserved_semispace_size_ to ensure that young
 // generation can be aligned to its size.
       survived_since_last_expansion_(0),
       sweep_generation_(0),
       always_allocate_scope_depth_(0),
       linear_allocation_scope_depth_(0),
       contexts_disposed_(0),
       global_ic_age_(0),
@@ skipping 51 matching lines @@
       last_idle_notification_gc_count_init_(false),
       mark_sweeps_since_idle_round_started_(0),
       gc_count_at_last_idle_gc_(0),
       scavenges_since_last_idle_round_(kIdleScavengeThreshold),
       gcs_since_last_deopt_(0),
 #ifdef VERIFY_HEAP
       no_weak_embedded_maps_verification_scope_depth_(0),
 #endif
       promotion_queue_(this),
       configured_(false),
+      limits_changed_from_defaults_(false),
       chunks_queued_for_free_(NULL),
       relocation_mutex_(NULL) {
   // Allow build-time customization of the max semispace size. Building
   // V8 with snapshots and a non-default max semispace size is much
   // easier if you can define it as part of the build environment.
 #if defined(V8_MAX_SEMISPACE_SIZE)
   max_semispace_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
 #endif

[Hannes Payer (out of office), 2013/09/19 14:50:57]

Can you bring back this newline?

-
   intptr_t max_virtual = OS::MaxVirtualMemory();
 
   if (max_virtual > 0) {
     if (code_range_size_ > 0) {
       // Reserve no more than 1/8 of the memory for the code range.
       code_range_size_ = Min(code_range_size_, max_virtual >> 3);
     }
   }
 
   memset(roots_, 0, sizeof(roots_[0]) * kRootListLength);
@@ skipping 6483 matching lines @@
 
 
 // TODO(1236194): Since the heap size is configurable on the command line
 // and through the API, we should gracefully handle the case that the heap
 // size is not big enough to fit all the initial objects.
 bool Heap::ConfigureHeap(int max_semispace_size,
                          intptr_t max_old_gen_size,
                          intptr_t max_executable_size) {
   if (HasBeenSetUp()) return false;
 
+  if (isolate_->is_memory_constrained() && !limits_changed_from_defaults_) {
+    // Update the default values if this is a memory constrained device.
+    // TODO(rmcilroy): Ideally these should be set correctly in the constructor
+    // based on this flag, but the flag isn't setup correctly at that point.
+    max_semispace_size_ = DEFAULT_SEMISPACE_MAX_SIZE / 4;
+    reserved_semispace_size_ = DEFAULT_SEMISPACE_MAX_SIZE / 4;
+    max_old_generation_size_ = DEFAULT_OLD_GENERATION_MAX_SIZE / 2;
+    max_executable_size_ = DEFAULT_EXECUTABLE_MAX_SIZE / 2;

[Hannes Payer (out of office), 2013/09/19 14:50:57]

The embedder would just set the right values, no memory_constrained guard
needed.

[rmcilroy, 2013/09/19 15:01:34]

The embedder doesn't need to set these values (if they are 0 then no changes are
made in this method). This branch is simply to set the initial set of default
values correctly based on the flag (see the comment above - this should really
be alongside the defaults set in the constructor, but can't due to the fact the
flags are set late). 

[Hannes Payer (out of office), 2013/09/19 16:25:28]

But SetResourceConstraints could just set it to the right values. That would
work, right?

[rmcilroy, 2013/09/19 19:46:11]

Do you mean the embedder could just pass the correct values to set?  If so, see
my comment above about not thinking we should require the embedder to know how
to set semispace/oldspace/etc. (they should only setting these values if they
really know what they are doing, otherwise we should do a good default IMO).

+  }
+
   if (FLAG_stress_compaction) {
     // This will cause more frequent GCs when stressing.
     max_semispace_size_ = Page::kPageSize;
   }
 
   if (max_semispace_size > 0) {
     if (max_semispace_size < Page::kPageSize) {
       max_semispace_size = Page::kPageSize;
       if (FLAG_trace_gc) {
         PrintPID("Max semispace size cannot be less than %dkbytes\n",
@@ skipping 20 matching lines @@
     // If we are not using snapshots we reserve space for the actual
     // max semispace size.
     reserved_semispace_size_ = max_semispace_size_;
   }
 
   if (max_old_gen_size > 0) max_old_generation_size_ = max_old_gen_size;
   if (max_executable_size > 0) {
     max_executable_size_ = RoundUp(max_executable_size, Page::kPageSize);
   }
 
+  if (max_semispace_size > 0 || max_old_gen_size > 0 ||
+      max_executable_size_ > 0) {
+    // Did we change anything from their defaults.
+    limits_changed_from_defaults_ = true;
+  }
+
   // The max executable size must be less than or equal to the max old
   // generation size.
   if (max_executable_size_ > max_old_generation_size_) {
     max_executable_size_ = max_old_generation_size_;
   }
 
   // The new space size must be a power of two to support single-bit testing
   // for containment.
   max_semispace_size_ = RoundUpToPowerOf2(max_semispace_size_);
   reserved_semispace_size_ = RoundUpToPowerOf2(reserved_semispace_size_);
@@ skipping 1359 matching lines @@
   if (FLAG_concurrent_recompilation) {
     heap_->relocation_mutex_->Lock();
 #ifdef DEBUG
     heap_->relocation_mutex_locked_by_optimizer_thread_ =
         heap_->isolate()->optimizing_compiler_thread()->IsOptimizerThread();
 #endif  // DEBUG
   }
 }
 
 } }  // namespace v8::internal