[libplatform] allow thread_pool_size to be > 4

src/libplatform/default-platform.cc

 // Copyright 2013 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/libplatform/default-platform.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "src/base/logging.h"
@@ skipping 12 matching lines @@
   platform->EnsureInitialized();
   return platform;
 }
 
 
 bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate) {
   return reinterpret_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate);
 }
 
 
-const int DefaultPlatform::kMaxThreadPoolSize = 4;
+const int DefaultPlatform::kDefaultThreadPoolSize = 4;
 
 
 DefaultPlatform::DefaultPlatform()
-    : initialized_(false), thread_pool_size_(0) {}
+    : initialized_(false),
+      max_thread_pool_size_(base::SysInfo::NumberOfProcessors()),
+      thread_pool_size_(kDefaultThreadPoolSize) {}
 
 
 DefaultPlatform::~DefaultPlatform() {
   base::LockGuard<base::Mutex> guard(&lock_);
   queue_.Terminate();
   if (initialized_) {
     for (auto i = thread_pool_.begin(); i != thread_pool_.end(); ++i) {
       delete *i;
     }
   }
@@ skipping 11 matching lines @@
       i->second.pop();
     }
   }
 }
 
 
 void DefaultPlatform::SetThreadPoolSize(int thread_pool_size) {
   base::LockGuard<base::Mutex> guard(&lock_);
   DCHECK(thread_pool_size >= 0);
   if (thread_pool_size < 1) {
-    thread_pool_size = base::SysInfo::NumberOfProcessors();
+    thread_pool_size = kDefaultThreadPoolSize;
   }
   thread_pool_size_ =
-      std::max(std::min(thread_pool_size, kMaxThreadPoolSize), 1);
+      std::max(std::min(thread_pool_size, max_thread_pool_size_), 1);

[jochen (gone - plz use gerrit), 2016/01/08 14:46:18]

any reason you store this in a member instead of just invoking
base::SysInfo::NumberOfProcessors() here?

note that NumberOfProcessors is actually just the number of processors online at
this point, so if your system doesn't have enough load, this might actually
restrict the thread pool size to less than four :-/

 }
 
 
 void DefaultPlatform::EnsureInitialized() {
   base::LockGuard<base::Mutex> guard(&lock_);
   if (initialized_) return;
   initialized_ = true;
 
   for (int i = 0; i < thread_pool_size_; ++i)
     thread_pool_.push_back(new WorkerThread(&queue_));
@@ skipping 105 matching lines @@
 }
 
 
 const char* DefaultPlatform::GetCategoryGroupName(
     const uint8_t* category_enabled_flag) {
   static const char dummy[] = "dummy";
   return dummy;
 }
 }  // namespace platform
 }  // namespace v8