Fixing --verify-predictable mode.

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"
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "src/base/sys-info.h"
+#include "src/flags.h"

[Igor Sheludko, 2015/11/10 10:41:06]

Unfortunately this violates "-src" directive from src/libplatform's
include_rules.

 #include "src/libplatform/worker-thread.h"
 
 namespace v8 {
 namespace platform {
 
 
 v8::Platform* CreateDefaultPlatform(int thread_pool_size) {
   DefaultPlatform* platform = new DefaultPlatform();
   platform->SetThreadPoolSize(thread_pool_size);
   platform->EnsureInitialized();
   return platform;
 }
 
 
 bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate) {
   return reinterpret_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate);
 }
 
 
 const int DefaultPlatform::kMaxThreadPoolSize = 4;
 
 
 DefaultPlatform::DefaultPlatform()
-    : initialized_(false), thread_pool_size_(0) {}
+    : initialized_(false), thread_pool_size_(0), synthetic_time_in_sec_(0.0) {}
 
 
 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 110 matching lines @@
 void DefaultPlatform::CallIdleOnForegroundThread(Isolate* isolate,
                                                  IdleTask* task) {
   UNREACHABLE();
 }
 
 
 bool DefaultPlatform::IdleTasksEnabled(Isolate* isolate) { return false; }
 
 
 double DefaultPlatform::MonotonicallyIncreasingTime() {
+  if (v8::internal::FLAG_verify_predictable) {

[Igor Sheludko, 2015/11/10 10:41:06]

We could probably make FLAG_verify_predictable read-only and set it to true when
VERIFY_PREDICTABLE macro is enabled.
Thus we could write #ifdef VERIFY_PREDICTABLE here...

[jochen (gone - plz use gerrit), 2015/11/10 23:20:06]

we can't rely on every embedder doing this. how about just not using this
function in verify predictable mode?

[Igor Sheludko, 2015/11/11 10:20:46]

1) The VERIFY_PREDICTABLE (and then --verify-predictable) is a special build&run
mode that was intended to help us to ensure that we know all sources of
non-determinism in V8 by calculating a hash sum of all allocations. I don't
think the embedders should care about this mode at all. Don't mix it up with
--predictable, which just disables threads and sets random seed.
2) Your idea is fine modulo the fact that several DefaultPlatform's methods also
call MonotonicallyIncreasingTime(), for example
DefaultPlatform::CallDelayedOnForegroundThread().

+    synthetic_time_in_sec_ += 0.000001;
+    return synthetic_time_in_sec_;
+  }
+
   return base::TimeTicks::HighResolutionNow().ToInternalValue() /
          static_cast<double>(base::Time::kMicrosecondsPerSecond);
 }
 }  // namespace platform
 }  // namespace v8