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

include/v8-platform.h

Index: include/v8-platform.h
diff --git a/src/hydrogen-bce.h b/include/v8-platform.h
similarity index 58%
copy from src/hydrogen-bce.h
copy to include/v8-platform.h
index c55dea7b7a5133b62b0e4fa81f1e4b3fa3022279..4fb8e6433544dffe0bf27411d9174fd9425b835b 100644
--- a/src/hydrogen-bce.h
+++ b/include/v8-platform.h
@@ -25,50 +25,51 @@
 // (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 {
 
-
-class BoundsCheckBbData;
-class BoundsCheckKey;
-class BoundsCheckTable : private ZoneHashMap {
+/**
+ * A Task represents a unit of work.
+ */
+class Task {
  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));
+  virtual ~Task() {}
 
- 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)

 };
 
-
-class HBoundsCheckEliminationPhase : public HPhase {
+/**
+ * V8 Platform abstraction layer.
+ *
+ * The embedder has to provide an implementation of this interface before
+ * initializing the rest of V8.
+ */
+class Platform {
  public:
-  explicit HBoundsCheckEliminationPhase(HGraph* graph)
-      : HPhase("H_Bounds checks elimination", graph), table_(zone()) { }
-
-  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);
+  /**
+   * 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

+
+  /**
+   * 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;
+
+ protected:
+  virtual ~Platform() {}
 };
 
+}  // namespace v8
 
-} }  // namespace v8::internal
-
-#endif  // V8_HYDROGEN_BCE_H_
+#endif  // V8_V8_PLATFORM_H_