Reland r17877 - Introduce a v8::Platform class that bundles embedder callbacks

include/v8-platform.h

 // Copyright 2013 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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#ifndef V8_HYDROGEN_BCE_H_
-#define V8_HYDROGEN_BCE_H_
+#ifndef V8_V8_PLATFORM_H_
+#define V8_V8_PLATFORM_H_
 
-#include "hydrogen.h"
+#include "v8.h"
 
 namespace v8 {
-namespace internal {
 
+/**
+ * A Task represents a unit of work.
+ */
+class Task {
+ public:
+  virtual ~Task() {}
 
-class BoundsCheckBbData;
-class BoundsCheckKey;
-class BoundsCheckTable : private ZoneHashMap {
- public:
-  explicit BoundsCheckTable(Zone* zone);
-
-  INLINE(BoundsCheckBbData** LookupOrInsert(BoundsCheckKey* key, Zone* zone));
-  INLINE(void Insert(BoundsCheckKey* key, BoundsCheckBbData* data, Zone* zone));
-  INLINE(void Delete(BoundsCheckKey* key));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(BoundsCheckTable);
+  virtual void Run() = 0;

[Sven Panne, 2013/11/21 07:43:25]

I think that at some point we need something like C++'s packaged_task / future /
promise. How will it fit into this?

[jochen (gone - plz use gerrit), 2013/11/21 10:43:42]

perfectly it will fit!

The main purpose of this class is to be able to delete whatever thing we end up
using. An implementation would look like this (in chromium).

class ConcreteTask : public Task {
 public:
  explicit ConcreteTask(const base::Closure& closure) : closure_(closure) {}
  virtual ~ConcreteTask() {}

  virtual void Run() { closure_.Run(); }
 private:
  base::Closure closure_;
};

you can then platform->CallOnBackgroundThread(new ConcreteTask(base::Bind(&Foo,
whatever, else)), false)

 };
 
+/**
+ * V8 Platform abstraction layer.
+ *
+ * The embedder has to provide an implementation of this interface before
+ * initializing the rest of V8.
+ */
+class Platform {
+ public:
+  /**
+   * Schedules a task to be invoked on a background thread. |task_is_slow|
+   * indicates that the task will run a long time. The Platform implementation
+   * takes ownership of |task|. There is no guarantee about order of execution
+   * of tasks wrt order of scheduling, nor is there a guarantee about the
+   * thread the task will be run on.
+   */
+  virtual void CallOnBackgroundThread(Task* task, bool task_is_slow) = 0;

[Sven Panne, 2013/11/21 07:43:25]

Hmmm, why do we need task_is_slow? And what exactly should it mean to be "slow"?
This seems to have very subjective semantics (= no semantics at all ;-), so I
would like to avoid such wishy-washy concepts in an API.

[Benedikt Meurer, 2013/11/21 07:49:27]

In case we need to keep the "task_is_slow" parameter, can we please turn it into
an enum then?

[jochen (gone - plz use gerrit), 2013/11/21 10:43:42]

It's basically mirroring the windows threading API.

This bool maps to the flag WT_EXECUTELONGFUNCTION

[jochen (gone - plz use gerrit), 2013/11/21 10:43:42]

sure

 
-class HBoundsCheckEliminationPhase : public HPhase {
- public:
-  explicit HBoundsCheckEliminationPhase(HGraph* graph)
-      : HPhase("H_Bounds checks elimination", graph), table_(zone()) { }
+  /**
+   * Schedules a task to be invoked on a foreground thread wrt a specific
+   * |isolate|. Tasks posted for the same isolate should be execute in order of
+   * scheduling. The definition of "foreground" is opaque to V8.
+   */
+  virtual void CallOnForegroundThread(Isolate* isolate, Task* task) = 0;
 
-  void Run() {
-    EliminateRedundantBoundsChecks(graph()->entry_block());
-  }
-
- private:
-  void EliminateRedundantBoundsChecks(HBasicBlock* bb);
-  BoundsCheckBbData* PreProcessBlock(HBasicBlock* bb);
-  void PostProcessBlock(HBasicBlock* bb, BoundsCheckBbData* data);
-
-  BoundsCheckTable table_;
-
-  DISALLOW_COPY_AND_ASSIGN(HBoundsCheckEliminationPhase);
+ protected:
+  virtual ~Platform() {}
 };
 
+}  // namespace v8
 
-} }  // namespace v8::internal
-
-#endif  // V8_HYDROGEN_BCE_H_
+#endif  // V8_V8_PLATFORM_H_