You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by ok...@apache.org on 2016/02/11 20:39:38 UTC
incubator-tinkerpop git commit: Okay. Here is is. g.V().pageRank().order.by(pageRank).name.limit(10). We know support chained OLAP jobs within a single Traversal. This is an amazing piece of code. There is still lots more to do, but the basic framework i

Repository: incubator-tinkerpop
Updated Branches:
  refs/heads/TINKERPOP-1140 3afc1894a -> a4cf1514d


Okay. Here is is. g.V().pageRank().order.by(pageRank).name.limit(10). We know support chained OLAP jobs within a single Traversal. This is an amazing piece of code. There is still lots more to do, but the basic framework is working and is sound. Note that we were able to loosen up lots of ComputerVerificaitonStrategy restrictions. Moreover, over the next couple of pushes, we will loosen up even more. The OrderStep comparator stuff was a rats nest that I have since cleaned up ... sometimes it wants a traverser, sometimes an object...random. I can't believe we haven't seen more bugs cause of what we had.


Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/a4cf1514
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/a4cf1514
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/a4cf1514

Branch: refs/heads/TINKERPOP-1140
Commit: a4cf1514d95dfd873675f08e6fd5d08aea810992
Parents: 3afc189
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Thu Feb 11 12:39:30 2016 -0700
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Thu Feb 11 12:39:30 2016 -0700

----------------------------------------------------------------------
 .../traversal/TraversalVertexProgram.java       |  19 ++--
 .../traversal/step/map/ComputerResultStep.java  |   6 +-
 .../step/map/PageRankVertexProgramStep.java     |  24 +++-
 .../step/map/TraversalVertexProgramStep.java    |  55 +++++++---
 .../mapreduce/ComputerToStandardMapReduce.java  | 110 +++++++++++++++++++
 .../mapreduce/TraverserMapReduce.java           |  56 ++++++++--
 .../traversal/dsl/graph/GraphTraversal.java     |  28 +++--
 .../step/util/TraversalComparator.java          |  20 +++-
 .../decoration/VertexProgramStrategy.java       |  53 +++++++--
 .../ComputerVerificationStrategy.java           |  65 ++++++-----
 .../util/DefaultTraverserGeneratorFactory.java  |   3 +-
 .../traversal/dsl/graph/GraphTraversalTest.java |   2 +-
 .../ComputerVerificationStrategyTest.java       |   2 +-
 .../step/map/GroovyPageRankTest.groovy          |  43 ++++++++
 .../process/GroovyProcessComputerSuite.java     |   2 +
 .../gremlin/process/ProcessComputerSuite.java   |   3 +
 .../process/traversal/step/map/OrderTest.java   |   7 +-
 .../traversal/step/map/PageRankTest.java        |  85 ++++++++++++++
 ...ComputerVerificationStrategyProcessTest.java |  26 +----
 .../process/computer/TinkerMessenger.java       |   2 +-
 .../TinkerGraphNoStrategyComputerProvider.java  |   2 +
 .../structure/TinkerGraphPlayTest.java          |  11 +-
 22 files changed, 509 insertions(+), 115 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/TraversalVertexProgram.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/TraversalVertexProgram.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/TraversalVertexProgram.java
index cabbf6c..573e826 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/TraversalVertexProgram.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/TraversalVertexProgram.java
@@ -19,7 +19,6 @@
 package org.apache.tinkerpop.gremlin.process.computer.traversal;
 
 import org.apache.commons.configuration.Configuration;
-import org.apache.tinkerpop.gremlin.process.computer.ComputerResult;
 import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
 import org.apache.tinkerpop.gremlin.process.computer.MapReduce;
 import org.apache.tinkerpop.gremlin.process.computer.Memory;
@@ -27,7 +26,6 @@ import org.apache.tinkerpop.gremlin.process.computer.MessageCombiner;
 import org.apache.tinkerpop.gremlin.process.computer.MessageScope;
 import org.apache.tinkerpop.gremlin.process.computer.Messenger;
 import org.apache.tinkerpop.gremlin.process.computer.VertexProgram;
-import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ComputerResultStep;
 import org.apache.tinkerpop.gremlin.process.computer.traversal.step.sideEffect.mapreduce.TraverserMapReduce;
 import org.apache.tinkerpop.gremlin.process.computer.util.AbstractVertexProgramBuilder;
 import org.apache.tinkerpop.gremlin.process.computer.util.ConfigurationTraversal;
@@ -41,6 +39,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectCapStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.ReducingBarrierStep;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet;
+import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalClassFunction;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMatrix;
@@ -148,10 +147,16 @@ public final class TraversalVertexProgram implements VertexProgram<TraverserSet<
             final TraverserSet<Object> haltedTraversers = new TraverserSet<>();
             vertex.property(VertexProperty.Cardinality.single, HALTED_TRAVERSERS, haltedTraversers);
 
-            if (!(this.traversal.getStartStep() instanceof GraphStep))
-                throw new UnsupportedOperationException("TraversalVertexProgram currently only supports GraphStep starts on vertices or edges");
-
-            final GraphStep<Element, Element> graphStep = (GraphStep<Element, Element>) this.traversal.getStartStep();
+            /*if (!(this.traversal.getStartStep() instanceof GraphStep)) {  // TODO: support reactivating halted traversers
+                final TraverserSet<Object> aliveTraverses = new TraverserSet<>();
+                aliveTraverses.addAll(haltedTraversers);
+                haltedTraversers.clear();
+                if (!haltedTraversers.isEmpty())
+                    messenger.sendMessage(MessageScope.Global.of(vertex), aliveTraverses);
+            }*/
+            final GraphStep<Element, Element> graphStep = (this.traversal.getStartStep() instanceof GraphStep) ?
+                    (GraphStep<Element, Element>) this.traversal.getStartStep() :
+                    new GraphStep((Traversal.Admin) EmptyTraversal.instance(), Vertex.class, true); // if no start vertices, then do all vertices
             final String future = graphStep.getNextStep().getId();
             final TraverserGenerator traverserGenerator = this.traversal.getTraverserGenerator();
             if (graphStep.returnsVertex()) {  // VERTICES (process the first step locally)
@@ -172,7 +177,7 @@ public final class TraversalVertexProgram implements VertexProgram<TraverserSet<
                     if (ElementHelper.idExists(start.id(), graphStep.getIds())) {
                         final Traverser.Admin<Element> traverser = traverserGenerator.generate(start, graphStep, 1l);
                         traverser.setStepId(future);
-                        traverser.detach();
+                        traverser.detach(); // TODO: bad
                         if (traverser.isHalted())
                             haltedTraversers.add((Traverser.Admin) traverser);
                         else {

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/ComputerResultStep.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/ComputerResultStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/ComputerResultStep.java
index fc63524..bf5586b 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/ComputerResultStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/ComputerResultStep.java
@@ -59,6 +59,7 @@ public final class ComputerResultStep<S> extends AbstractStep<ComputerResult, S>
 
     public Iterator<Traverser.Admin<S>> attach(final Iterator<Traverser.Admin<S>> iterator, final Graph graph) {
         return IteratorUtils.map(iterator, traverser -> {
+            traverser.setSideEffects(this.getTraversal().getSideEffects());   // necessary to ensure no NPE
             if (this.attachElements && (traverser.get() instanceof Attachable))
                 traverser.set((S) ((Attachable<Element>) traverser.get()).attach(Attachable.Method.get(graph)));
             return traverser;
@@ -75,7 +76,7 @@ public final class ComputerResultStep<S> extends AbstractStep<ComputerResult, S>
                 result.memory().keys().forEach(key -> this.getTraversal().getSideEffects().set(key, result.memory().get(key)));
                 final Step endStep = this.getPreviousStep() instanceof TraversalVertexProgramStep ?
                         ((TraversalVertexProgramStep) this.getPreviousStep()).computerTraversal.getEndStep() :
-                        EmptyStep.instance();
+                        EmptyStep.instance();   // TODO: need to be selective and smart
                 if (endStep instanceof SideEffectCapStep) {
                     final List<String> sideEffectKeys = ((SideEffectCapStep<?, ?>) endStep).getSideEffectKeys();
                     if (sideEffectKeys.size() == 1)
@@ -90,8 +91,9 @@ public final class ComputerResultStep<S> extends AbstractStep<ComputerResult, S>
                 } else if (result.memory().exists(ReducingBarrierStep.REDUCING)) {
                     this.currentIterator = this.getTraversal().getTraverserGenerator().generateIterator(IteratorUtils.of(result.memory().get(ReducingBarrierStep.REDUCING)), (Step) this, 1l);
                 } else {
-                    this.currentIterator = this.attach(result.memory().get(TraverserMapReduce.TRAVERSERS), result.graph());
+                    this.currentIterator = result.memory().get(TraverserMapReduce.TRAVERSERS);
                 }
+                this.currentIterator = attach(this.currentIterator, result.graph());
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/PageRankVertexProgramStep.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/PageRankVertexProgramStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/PageRankVertexProgramStep.java
index 6743ee5..c0f556c 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/PageRankVertexProgramStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/PageRankVertexProgramStep.java
@@ -24,6 +24,7 @@ import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
 import org.apache.tinkerpop.gremlin.process.computer.ranking.pagerank.PageRankVertexProgram;
 import org.apache.tinkerpop.gremlin.process.computer.traversal.step.VertexComputing;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
 import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
@@ -32,6 +33,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 
 import java.util.Collections;
 import java.util.List;
@@ -46,12 +48,14 @@ public final class PageRankVertexProgramStep extends AbstractStep<ComputerResult
 
     private transient Function<Graph, GraphComputer> graphComputerFunction = Graph::compute;
 
-    private Traversal.Admin<Vertex, Edge> pageRankTraversal = __.<Vertex>outE().asAdmin();  // need to compile against the ComputerResult.graph()
+    private Traversal.Admin<Vertex, Edge> pageRankTraversal;
+    private Traversal.Admin<Vertex, Edge> purePageRankTraversal;
     private boolean first = true;
 
 
     public PageRankVertexProgramStep(final Traversal.Admin traversal) {
         super(traversal);
+        this.addLocalChild(__.<Vertex>outE().asAdmin());
     }
 
     @Override
@@ -61,12 +65,12 @@ public final class PageRankVertexProgramStep extends AbstractStep<ComputerResult
                 this.first = false;
                 final Graph graph = this.getTraversal().getGraph().get();
                 final GraphComputer graphComputer = this.graphComputerFunction.apply(graph).persist(GraphComputer.Persist.EDGES);
-                return this.traversal.getTraverserGenerator().generate(graphComputer.program(PageRankVertexProgram.build().traversal(this.pageRankTraversal).create(graph)).submit().get(), this, 1l);
+                return this.traversal.getTraverserGenerator().generate(graphComputer.program(PageRankVertexProgram.build().traversal(this.compileTraversal(graph)).create(graph)).submit().get(), this, 1l);
             } else {
                 final Traverser.Admin<ComputerResult> traverser = this.starts.next();
                 final Graph graph = traverser.get().graph();
                 final GraphComputer graphComputer = this.graphComputerFunction.apply(graph).persist(GraphComputer.Persist.EDGES);
-                return traverser.split(graphComputer.program(PageRankVertexProgram.build().traversal(this.pageRankTraversal).create(graph)).submit().get(), this);
+                return traverser.split(graphComputer.program(PageRankVertexProgram.build().traversal(this.compileTraversal(graph)).create(graph)).submit().get(), this);
             }
         } catch (final InterruptedException | ExecutionException e) {
             throw new IllegalStateException(e.getMessage(), e);
@@ -76,6 +80,7 @@ public final class PageRankVertexProgramStep extends AbstractStep<ComputerResult
     @Override
     public void addLocalChild(final Traversal.Admin<?, ?> localChildTraversal) {
         this.pageRankTraversal = this.integrateChild((Traversal.Admin) localChildTraversal);
+        this.purePageRankTraversal = this.pageRankTraversal.clone();
     }
 
     @Override
@@ -84,14 +89,27 @@ public final class PageRankVertexProgramStep extends AbstractStep<ComputerResult
     }
 
     @Override
+    public String toString() {
+        return StringFactory.stepString(this, this.pageRankTraversal);
+    }
+
+    @Override
     public void setGraphComputerFunction(final Function<Graph, GraphComputer> graphComputerFunction) {
         this.graphComputerFunction = graphComputerFunction;
     }
 
+    private final Traversal.Admin<Vertex, Edge> compileTraversal(final Graph graph) {
+        final Traversal.Admin<Vertex, Edge> compiledPageRankTraversal = this.purePageRankTraversal.clone();
+        compiledPageRankTraversal.setStrategies(TraversalStrategies.GlobalCache.getStrategies(graph.getClass()));
+        compiledPageRankTraversal.applyStrategies();
+        return compiledPageRankTraversal;
+    }
+
     @Override
     public PageRankVertexProgramStep clone() {
         final PageRankVertexProgramStep clone = (PageRankVertexProgramStep) super.clone();
         clone.pageRankTraversal = clone.integrateChild(this.pageRankTraversal);
+        clone.purePageRankTraversal = clone.integrateChild(this.purePageRankTraversal);
         return clone;
     }
 }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/TraversalVertexProgramStep.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/TraversalVertexProgramStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/TraversalVertexProgramStep.java
index 120cda9..500de8a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/TraversalVertexProgramStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/map/TraversalVertexProgramStep.java
@@ -22,31 +22,38 @@ package org.apache.tinkerpop.gremlin.process.computer.traversal.step.map;
 import org.apache.tinkerpop.gremlin.process.computer.ComputerResult;
 import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
 import org.apache.tinkerpop.gremlin.process.computer.traversal.TraversalVertexProgram;
+import org.apache.tinkerpop.gremlin.process.computer.traversal.step.VertexComputing;
 import org.apache.tinkerpop.gremlin.process.traversal.Step;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
 import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.AbstractStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
-import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException;
+import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Function;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  */
-public final class TraversalVertexProgramStep extends AbstractStep<ComputerResult, ComputerResult> implements TraversalParent {
+public final class TraversalVertexProgramStep extends AbstractStep<ComputerResult, ComputerResult> implements TraversalParent, VertexComputing {
 
+    private transient Function<Graph, GraphComputer> graphComputerFunction = Graph::compute;
     public Traversal.Admin<?, ?> computerTraversal;
-    private final transient GraphComputer graphComputer;
+    public Traversal.Admin<?, ?> pureComputerTraversal;
+
     private boolean first = true;
 
-    public TraversalVertexProgramStep(final Traversal.Admin traversal, final Traversal.Admin<?, ?> computerTraversal, final GraphComputer graphComputer) {
+    public TraversalVertexProgramStep(final Traversal.Admin traversal, final Traversal.Admin<?, ?> computerTraversal) {
         super(traversal);
-        this.graphComputer = graphComputer;
+        this.pureComputerTraversal = computerTraversal.clone();
         this.computerTraversal = this.integrateChild(computerTraversal);
     }
 
@@ -56,28 +63,35 @@ public final class TraversalVertexProgramStep extends AbstractStep<ComputerResul
 
     @Override
     protected Traverser<ComputerResult> processNextStart() {
-
-        if (this.first) { // && previousStep EmptyStep
-            try {
+        try {
+            if (this.first && this.getPreviousStep() instanceof EmptyStep) {
                 this.first = false;
-                final ComputerResult result = this.graphComputer.program(TraversalVertexProgram.build().traversal(this.computerTraversal).create(this.getTraversal().getGraph().get())).submit().get();
+                final Graph graph = this.getTraversal().getGraph().get();
+                final GraphComputer graphComputer = this.graphComputerFunction.apply(graph);
+                final ComputerResult result = graphComputer.program(TraversalVertexProgram.build().traversal(this.compileTraversal(graph)).create(this.getTraversal().getGraph().get())).submit().get();
                 return this.getTraversal().getTraverserGenerator().generate(result, (Step) this, 1l);
-            } catch (final Exception e) {
-                throw new IllegalStateException(e.getMessage(), e);
+            } else {
+                final Traverser.Admin<ComputerResult> traverser = this.starts.next();
+                final Graph graph = traverser.get().graph();
+                final GraphComputer graphComputer = this.graphComputerFunction.apply(graph);
+                final ComputerResult result = graphComputer.program(TraversalVertexProgram.build().traversal(this.compileTraversal(graph)).create(graph)).submit().get();
+                return traverser.split(result, this);
             }
+        } catch (final InterruptedException | ExecutionException e) {
+            throw new IllegalStateException(e.getMessage(), e);
         }
-        throw FastNoSuchElementException.instance();
     }
 
     @Override
     public String toString() {
-        return StringFactory.stepString(this, this.computerTraversal, this.graphComputer);
+        return StringFactory.stepString(this, this.computerTraversal);
     }
 
     @Override
     public TraversalVertexProgramStep clone() {
         final TraversalVertexProgramStep clone = (TraversalVertexProgramStep) super.clone();
         clone.computerTraversal = this.integrateChild(this.computerTraversal.clone());
+        clone.pureComputerTraversal = this.pureComputerTraversal.clone();
         return clone;
     }
 
@@ -85,4 +99,19 @@ public final class TraversalVertexProgramStep extends AbstractStep<ComputerResul
     public Set<TraverserRequirement> getRequirements() {
         return TraversalParent.super.getSelfAndChildRequirements(TraverserRequirement.BULK);
     }
+
+    private final Traversal.Admin<?, ?> compileTraversal(final Graph graph) {
+        final Traversal.Admin<?, ?> compiledComputerTraversal = this.pureComputerTraversal.clone();
+        compiledComputerTraversal.setStrategies(TraversalStrategies.GlobalCache.getStrategies(graph.getClass()).clone());
+        this.getTraversal().getStrategies().toList().forEach(compiledComputerTraversal.getStrategies()::addStrategies);
+        compiledComputerTraversal.setParent(this);
+        compiledComputerTraversal.setSideEffects(this.computerTraversal.getSideEffects());
+        compiledComputerTraversal.applyStrategies();
+        return compiledComputerTraversal;
+    }
+
+    @Override
+    public void setGraphComputerFunction(final Function<Graph, GraphComputer> graphComputerFunction) {
+        this.graphComputerFunction = graphComputerFunction;
+    }
 }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/ComputerToStandardMapReduce.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/ComputerToStandardMapReduce.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/ComputerToStandardMapReduce.java
new file mode 100644
index 0000000..84f939e
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/ComputerToStandardMapReduce.java
@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tinkerpop.gremlin.process.computer.traversal.step.sideEffect.mapreduce;
+
+import org.apache.commons.configuration.Configuration;
+import org.apache.tinkerpop.gremlin.process.computer.KeyValue;
+import org.apache.tinkerpop.gremlin.process.computer.MapReduce;
+import org.apache.tinkerpop.gremlin.process.computer.traversal.TraversalVertexProgram;
+import org.apache.tinkerpop.gremlin.process.computer.util.VertexProgramHelper;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep;
+import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+
+import java.util.Iterator;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public final class ComputerToStandardMapReduce implements MapReduce<MapReduce.NullObject, Traverser<?>, MapReduce.NullObject, Traverser<?>, Iterator<Traverser<?>>> {
+
+    private static final String VERTEX_TRAVERSAL = "gremlin.computerToStandardMapReduce.vertexTraversal";
+
+    private Traversal.Admin<Vertex, ?> traversal;
+
+    private ComputerToStandardMapReduce() {
+    }
+
+    public ComputerToStandardMapReduce(final Traversal.Admin<Vertex, ?> traversal) {
+        this.traversal = traversal;
+    }
+
+    @Override
+    public void loadState(final Graph graph, final Configuration configuration) {
+        this.traversal = VertexProgramHelper.deserialize(configuration, VERTEX_TRAVERSAL);
+    }
+
+    @Override
+    public void storeState(final Configuration configuration) {
+        MapReduce.super.storeState(configuration);
+        VertexProgramHelper.serialize(this.traversal, configuration, VERTEX_TRAVERSAL);
+    }
+
+
+    @Override
+    public boolean doStage(final Stage stage) {
+        return stage.equals(Stage.MAP); // || this.access.equals(Access.HALTED);
+    }
+
+    @Override
+    public void map(final Vertex vertex, final MapEmitter<NullObject, Traverser<?>> emitter) {
+        this.traversal.addStart(this.traversal.getTraverserGenerator().generate(vertex, this.traversal.getStartStep(), 1l));
+        this.traversal.getEndStep().forEachRemaining(emitter::emit);
+    }
+
+    @Override
+    public void combine(final NullObject key, final Iterator<Traverser<?>> values, final ReduceEmitter<NullObject, Traverser<?>> emitter) {
+        this.reduce(key, values, emitter);
+    }
+
+    @Override
+    public void reduce(final NullObject key, final Iterator<Traverser<?>> values, final ReduceEmitter<NullObject, Traverser<?>> emitter) {
+        final TraverserSet<?> traverserSet = new TraverserSet<>();
+        while (values.hasNext()) {
+            traverserSet.add((Traverser.Admin) values.next().asAdmin());
+        }
+        IteratorUtils.removeOnNext(traverserSet.iterator()).forEachRemaining(emitter::emit);
+    }
+
+    @Override
+    public Iterator<Traverser<?>> generateFinalResult(final Iterator<KeyValue<NullObject, Traverser<?>>> keyValues) {
+        return IteratorUtils.map(keyValues, KeyValue::getValue);
+    }
+
+    @Override
+    public String getMemoryKey() {
+        return TraverserMapReduce.TRAVERSERS;
+    }
+
+    @Override
+    public ComputerToStandardMapReduce clone() {
+       try {
+            final ComputerToStandardMapReduce clone = (ComputerToStandardMapReduce) super.clone();
+            clone.traversal = this.traversal.clone();
+            return clone;
+        } catch (final CloneNotSupportedException e) {
+            throw new IllegalStateException(e.getMessage(), e);
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/TraverserMapReduce.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/TraverserMapReduce.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/TraverserMapReduce.java
index 06d2228..88cb09c 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/TraverserMapReduce.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/traversal/step/sideEffect/mapreduce/TraverserMapReduce.java
@@ -25,14 +25,26 @@ import org.apache.tinkerpop.gremlin.process.computer.util.StaticMapReduce;
 import org.apache.tinkerpop.gremlin.process.traversal.Step;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.ElementValueTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.TokenTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupGlobalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TailGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.EdgeVertexStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertyMapStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.CollectingBarrierStep;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.VerificationException;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet;
+import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
+import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.util.Attachable;
 import org.apache.tinkerpop.gremlin.util.function.ChainedComparator;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
@@ -50,6 +62,7 @@ public final class TraverserMapReduce extends StaticMapReduce<Comparable, Traver
     private Traversal.Admin<?, ?> traversal;
     private Optional<Comparator<Comparable>> comparator = Optional.empty();
     private Optional<CollectingBarrierStep<?>> collectingBarrierStep = Optional.empty();
+    private boolean attachHaltedTraverser = false;
     private Optional<RangeGlobalStep<?>> rangeGlobalStep = Optional.empty();
     private Optional<TailGlobalStep<?>> tailGlobalStep = Optional.empty();
     private boolean dedupGlobal = false;
@@ -71,8 +84,11 @@ public final class TraverserMapReduce extends StaticMapReduce<Comparable, Traver
     private void genericLoadState() {
         final Step<?, ?> traversalEndStep = traversal.getEndStep();
         this.comparator = Optional.ofNullable(traversalEndStep instanceof OrderGlobalStep ? new ChainedComparator<Comparable>(((OrderGlobalStep) traversalEndStep).getComparators()) : null);
-        if (!this.comparator.isPresent() && traversalEndStep instanceof CollectingBarrierStep)
-            this.collectingBarrierStep = Optional.of((CollectingBarrierStep<?>) traversalEndStep);
+        if (traversalEndStep instanceof CollectingBarrierStep) {
+            this.collectingBarrierStep = Optional.of((CollectingBarrierStep<?>) traversalEndStep); // why no clone() like the others?
+            if (this.collectingBarrierStep.get() instanceof TraversalParent)
+                this.attachHaltedTraverser = ((TraversalParent) this.collectingBarrierStep.get()).getLocalChildren().stream().filter(TraverserMapReduce::isBeyondElementId).findAny().isPresent();
+        }
         if (traversalEndStep instanceof RangeGlobalStep)
             this.rangeGlobalStep = Optional.of(((RangeGlobalStep) traversalEndStep).clone());
         if (traversalEndStep instanceof TailGlobalStep)
@@ -89,10 +105,17 @@ public final class TraverserMapReduce extends StaticMapReduce<Comparable, Traver
 
     @Override
     public void map(final Vertex vertex, final MapEmitter<Comparable, Traverser<?>> emitter) {
-        if (this.comparator.isPresent())
-            vertex.<TraverserSet<?>>property(TraversalVertexProgram.HALTED_TRAVERSERS).ifPresent(traverserSet -> traverserSet.forEach(traverser -> emitter.emit(traverser, traverser)));
-        else
-            vertex.<TraverserSet<?>>property(TraversalVertexProgram.HALTED_TRAVERSERS).ifPresent(traverserSet -> traverserSet.forEach(emitter::emit));
+        vertex.<TraverserSet<Object>>property(TraversalVertexProgram.HALTED_TRAVERSERS).ifPresent(traverserSet -> IteratorUtils.removeOnNext(traverserSet.iterator()).forEachRemaining(traverser -> {
+            if (this.attachHaltedTraverser) {
+                if (traverser.get() instanceof Edge)
+                    throw new VerificationException("Edges can not be accessed -- this should really be caught at compile time", EmptyTraversal.instance());
+                traverser.attach(Attachable.Method.get(vertex));
+            }
+            if (this.comparator.isPresent())    // TODO: I think we shouldn't ever single key it  -- always double emit to load balance the servers.
+                emitter.emit(traverser, traverser);
+            else
+                emitter.emit(traverser);
+        }));
     }
 
     @Override
@@ -111,7 +134,7 @@ public final class TraverserMapReduce extends StaticMapReduce<Comparable, Traver
         while (values.hasNext()) {
             traverserSet.add((Traverser.Admin) values.next().asAdmin());
         }
-        traverserSet.forEach(emitter::emit);
+        IteratorUtils.removeOnNext(traverserSet.iterator()).forEachRemaining(emitter::emit);
     }
 
     @Override
@@ -147,4 +170,23 @@ public final class TraverserMapReduce extends StaticMapReduce<Comparable, Traver
     public String getMemoryKey() {
         return TRAVERSERS;
     }
+
+    /////////////////////
+    /////////////////////
+
+    /*
+   * THIS NEEDS TO GO INTO TRAVERSAL HELPER ONCE WE GET THIS ALL STRAIGHTENED OUT WITH THE INSTRUCTION SET OF GREMLIN (TODO:)
+   */
+    private static boolean isBeyondElementId(final Traversal.Admin<?, ?> traversal) {
+        return (traversal instanceof TokenTraversal && !((TokenTraversal) traversal).getToken().equals(T.id)) || traversal instanceof ElementValueTraversal ||
+                traversal.getSteps().stream()
+                        .filter(step -> step instanceof VertexStep ||
+                                step instanceof EdgeVertexStep ||
+                                step instanceof PropertiesStep ||
+                                step instanceof PropertyMapStep ||
+                                (step instanceof TraversalParent &&
+                                        (((TraversalParent) step).getLocalChildren().stream().filter(TraverserMapReduce::isBeyondElementId).findAny().isPresent() ||
+                                                ((TraversalParent) step).getGlobalChildren().stream().filter(TraverserMapReduce::isBeyondElementId).findAny().isPresent())))
+                        .findAny().isPresent();
+    }
 }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index 473628f..9d60f46 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
@@ -18,6 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.process.traversal.dsl.graph;
 
+import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.PageRankVertexProgramStep;
 import org.apache.tinkerpop.gremlin.process.traversal.Order;
 import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.process.traversal.Path;
@@ -125,8 +126,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StoreStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TraversalSideEffectStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeSideEffectStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.util.ElementFunctionComparator;
-import org.apache.tinkerpop.gremlin.process.traversal.step.util.ElementValueComparator;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.FunctionComparator;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.TraversalComparator;
@@ -1149,6 +1148,13 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
         return this.asAdmin().addStep(new LocalStep<>(this.asAdmin(), localTraversal.asAdmin()));
     }
 
+    /////////////////// VERTEX PROGRAM STEPS ////////////////
+
+    public default GraphTraversal<S, E> pageRank() {
+        return this.asAdmin().addStep((Step<?, E>) new PageRankVertexProgramStep(this.asAdmin()));
+    }
+
+
     ///////////////////// UTILITY STEPS /////////////////////
 
     public default GraphTraversal<S, E> as(final String stepLabel, final String... stepLabels) {
@@ -1202,7 +1208,7 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
     //// COMPARATOR BY-MODULATORS
 
     public default GraphTraversal<S, E> by(final Comparator<E> comparator) {
-        ((ComparatorHolder<E>) this.asAdmin().getEndStep()).addComparator(comparator);
+        this.by(new IdentityTraversal<>(), comparator);
         return this;
     }
 
@@ -1211,23 +1217,27 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
     }
 
     public default <V> GraphTraversal<S, E> by(final Column column, final Comparator<V> objectComparator) {
-        return this.by(new FunctionComparator(column, objectComparator));
+        return this.by(new FunctionComparator<>((Function) column, objectComparator));
     }
 
     public default <V> GraphTraversal<S, E> by(final Function<Element, V> elementFunctionProjection,
                                                final Comparator<V> elementFunctionValueComparator) {
-        return ((Function) elementFunctionProjection) instanceof Column ?
-                this.by((Column) ((Function) elementFunctionProjection), elementFunctionValueComparator) :
-                this.by((Comparator) new ElementFunctionComparator<>(elementFunctionProjection, elementFunctionValueComparator));
+        if (((Function) elementFunctionProjection) instanceof Column)
+            return this.by((Column) ((Function) elementFunctionProjection), elementFunctionValueComparator);
+        else if (elementFunctionProjection instanceof T)
+            return this.by(new TokenTraversal<>((T) elementFunctionProjection), elementFunctionValueComparator);
+        else
+            return this.by(__.map((Function) elementFunctionProjection), elementFunctionValueComparator);
     }
 
     public default <V> GraphTraversal<S, E> by(final String elementPropertyProjection,
                                                final Comparator<V> propertyValueComparator) {
-        return this.by((Comparator) new ElementValueComparator<>(elementPropertyProjection, propertyValueComparator));
+        return this.by(new ElementValueTraversal<>(elementPropertyProjection), propertyValueComparator);
     }
 
     public default <V> GraphTraversal<S, E> by(final Traversal<?, ?> traversal, final Comparator<V> endComparator) {
-        return this.by(new TraversalComparator(traversal.asAdmin(), endComparator));
+        ((ComparatorHolder<E>) this.asAdmin().getEndStep()).addComparator(new TraversalComparator(traversal.asAdmin(), endComparator));
+        return this;
     }
 
     ////

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TraversalComparator.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TraversalComparator.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TraversalComparator.java
index fe65d58..24e3829 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TraversalComparator.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/TraversalComparator.java
@@ -20,15 +20,18 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.util;
 
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
 
 import java.io.Serializable;
+import java.util.Collections;
 import java.util.Comparator;
+import java.util.List;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  */
-public final class TraversalComparator<S, E> implements Comparator<S>, Serializable, Cloneable {
+public final class TraversalComparator<S, E> implements Comparator<S>, Serializable, Cloneable, TraversalParent {
 
     private Traversal.Admin<S, E> traversal;
     private final Comparator<E> comparator;
@@ -38,6 +41,10 @@ public final class TraversalComparator<S, E> implements Comparator<S>, Serializa
         this.comparator = comparator;
     }
 
+    public List<Traversal.Admin<S, E>> getLocalChildren() {
+        return Collections.singletonList(this.traversal);
+    }
+
     @Override
     public String toString() {
         return this.comparator.toString() + "(" + this.traversal + ")";
@@ -45,9 +52,14 @@ public final class TraversalComparator<S, E> implements Comparator<S>, Serializa
 
     @Override
     public int compare(final S start1, final S start2) {
-        return start1 instanceof Traverser ?
-                this.comparator.compare(TraversalUtil.apply((Traverser.Admin<S>) start1, this.traversal), TraversalUtil.apply((Traverser.Admin<S>) start2, this.traversal)) :
-                this.comparator.compare(TraversalUtil.apply(start1, this.traversal), TraversalUtil.apply(start2, this.traversal));
+        if (start1 instanceof Traverser && start2 instanceof Traverser)
+            return this.comparator.compare(TraversalUtil.apply((Traverser.Admin<S>) start1, this.traversal), TraversalUtil.apply((Traverser.Admin<S>) start2, this.traversal));
+        else if (start1 instanceof Traverser)
+            return this.comparator.compare(TraversalUtil.apply((Traverser.Admin<S>) start1, this.traversal), TraversalUtil.apply(start2, this.traversal));
+        else if (start2 instanceof Traverser)
+            return this.comparator.compare(TraversalUtil.apply(start1, this.traversal), TraversalUtil.apply((Traverser.Admin<S>) start2, this.traversal));
+        else
+            return this.comparator.compare(TraversalUtil.apply(start1, this.traversal), TraversalUtil.apply(start2, this.traversal));
     }
 
     @Override

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategy.java
index 9a2908c..8fbfb4f 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/VertexProgramStrategy.java
@@ -20,9 +20,11 @@
 package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
 
 import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
+import org.apache.tinkerpop.gremlin.process.computer.traversal.step.VertexComputing;
 import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ComputerResultStep;
 import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.PageRankVertexProgramStep;
 import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.TraversalVertexProgramStep;
+import org.apache.tinkerpop.gremlin.process.traversal.Step;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
@@ -30,6 +32,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ComputerVerificationStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.VerificationException;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal;
@@ -58,21 +61,55 @@ public final class VertexProgramStrategy extends AbstractTraversalStrategy<Trave
     public void apply(final Traversal.Admin<?, ?> traversal) {
         traversal.addTraverserRequirement(TraverserRequirement.BULK); // all graph computations require bulk
         if (traversal.getParent() instanceof EmptyStep) {  // VertexPrograms can only execute at the root level of a Traversal
-            if (traversal.getStartStep() instanceof GraphStep && traversal.getStartStep().getNextStep() instanceof PageRankVertexProgramStep) {
-                traversal.removeStep(0);
-                TraversalHelper.insertAfterStep(new ComputerResultStep<>(traversal, true), (PageRankVertexProgramStep) traversal.getStartStep().getNextStep(), traversal);
+            if (traversal.getStartStep() instanceof GraphStep && (traversal.getStartStep().getNextStep() instanceof PageRankVertexProgramStep)) {
+                final GraphStep<?, ?> graphStep = (GraphStep) traversal.getStartStep();
+                final PageRankVertexProgramStep pageRankVertexProgramStep = (PageRankVertexProgramStep) traversal.getStartStep().getNextStep();
+                if (!graphStep.returnsVertex())
+                    throw new VerificationException("The GraphStep previous to PageRankVertexStep must emit vertices: " + graphStep, traversal);
+                pageRankVertexProgramStep.setGraphComputerFunction(this.graphComputerFunction);
+                graphStep.getLabels().forEach(pageRankVertexProgramStep::addLabel);
+                traversal.removeStep(0);  // remove the graph step
             }
             if (null != this.graphComputerFunction) {   // if the function is null, then its been serialized and thus, already in a graph computer
-                Traversal.Admin<?, ?> newTraversal = new DefaultTraversal<>();
-                TraversalHelper.removeToTraversal(traversal.getStartStep(), EmptyStep.instance(), (Traversal.Admin) newTraversal);
-                traversal.addStep(new TraversalVertexProgramStep(traversal, newTraversal, this.graphComputerFunction.apply(traversal.getGraph().get())));
-                traversal.addStep(new ComputerResultStep<>(traversal, true));
+                Traversal.Admin<?, ?> computerTraversal = new DefaultTraversal<>();
+                Step<?, ?> firstLegalOLAPStep = getFirstLegalOLAPStep(traversal.getStartStep());
+                Step<?, ?> lastLegalOLAPStep = getLastLegalOLAPStep(traversal.getStartStep());
+                if (!(firstLegalOLAPStep instanceof EmptyStep)) {
+                    int index = TraversalHelper.stepIndex(firstLegalOLAPStep, traversal);
+                    TraversalHelper.removeToTraversal(firstLegalOLAPStep, lastLegalOLAPStep.getNextStep(), (Traversal.Admin) computerTraversal);
+                    final TraversalVertexProgramStep traversalVertexProgramStep = new TraversalVertexProgramStep(traversal, computerTraversal);
+                    traversalVertexProgramStep.setGraphComputerFunction(this.graphComputerFunction);
+                    final ComputerResultStep computerResultStep = new ComputerResultStep(traversal, true);
+                    if (!lastLegalOLAPStep.getLabels().isEmpty())
+                        lastLegalOLAPStep.getLabels().forEach(computerResultStep::addLabel);
+                    traversal.addStep(index, traversalVertexProgramStep);
+                    traversal.addStep(index + 1, computerResultStep);
+                }
             } else {  // this is a total hack to trick the difference between TraversalVertexProgram via GraphComputer and via TraversalSource. :|
-                traversal.setParent(new TraversalVertexProgramStep(EmptyTraversal.instance(), EmptyTraversal.instance(), null));
+                traversal.setParent(new TraversalVertexProgramStep(EmptyTraversal.instance(), EmptyTraversal.instance()));
                 ComputerVerificationStrategy.instance().apply(traversal);
                 traversal.setParent(EmptyStep.instance());
             }
         }
+
+    }
+
+    private static Step<?, ?> getFirstLegalOLAPStep(Step<?, ?> currentStep) {
+        while (!(currentStep instanceof EmptyStep)) {
+            if (!(currentStep instanceof VertexComputing))
+                return currentStep;
+            currentStep = currentStep.getNextStep();
+        }
+        return EmptyStep.instance();
+    }
+
+    private static Step<?, ?> getLastLegalOLAPStep(Step<?, ?> currentStep) {
+        while (!(currentStep instanceof EmptyStep)) {
+            if (ComputerVerificationStrategy.isStepInstanceOfEndStep(currentStep))
+                return currentStep;
+            currentStep = currentStep.getNextStep();
+        }
+        return EmptyStep.instance();
     }
 
     public static Optional<GraphComputer> getGraphComputer(final Graph graph, final TraversalStrategies strategies) {

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategy.java
index b8b8be4..1bbfd79 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategy.java
@@ -22,8 +22,6 @@ import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.Traversa
 import org.apache.tinkerpop.gremlin.process.traversal.Step;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.lambda.ElementValueTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.lambda.TokenTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.step.Bypassing;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GraphComputing;
 import org.apache.tinkerpop.gremlin.process.traversal.step.Mutating;
@@ -35,21 +33,17 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalSte
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TailGlobalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WherePredicateStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WhereTraversalStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.EdgeVertexStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderGlobalStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertyMapStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.CollectingBarrierStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.ComputerAwareStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.ReducingBarrierStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.SupplyingBarrierStep;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
-import org.apache.tinkerpop.gremlin.structure.T;
 
 import java.util.Arrays;
 import java.util.HashSet;
@@ -66,9 +60,26 @@ public final class ComputerVerificationStrategy extends AbstractTraversalStrateg
             InjectStep.class, Mutating.class, SubgraphStep.class
     ));
 
+    public static final Set<Class<? extends Step>> END_STEPS = new HashSet<>(Arrays.asList(
+            ReducingBarrierStep.class,
+            SupplyingBarrierStep.class,
+            OrderGlobalStep.class,
+            RangeGlobalStep.class,
+            TailGlobalStep.class,
+            DedupGlobalStep.class));
+
     private ComputerVerificationStrategy() {
     }
 
+    public static boolean isStepInstanceOfEndStep(final Step<?, ?> step) {
+        final Class<? extends Step> stepClass = step.getClass();
+        for (final Class<? extends Step> endClass : END_STEPS) {
+            if (endClass.isAssignableFrom(stepClass))
+                return true;
+        }
+        return false;
+    }
+
 
     private static void onlyGlobalChildren(final Traversal.Admin<?, ?> traversal) {
         for (final Step step : traversal.getSteps()) {
@@ -92,15 +103,12 @@ public final class ComputerVerificationStrategy extends AbstractTraversalStrateg
         }
 
         if (traversal.getParent() instanceof TraversalVertexProgramStep) {
-            if (!(traversal.getStartStep() instanceof GraphStep))
-                throw new VerificationException("GraphComputer does not support traversals starting from a non-GraphStep: " + traversal.getStartStep(), traversal);
-            ///
-            if (traversal.getSteps().stream().filter(step -> step instanceof GraphStep).count() > 1)
+            if (traversal.getStartStep() instanceof GraphStep && traversal.getSteps().stream().filter(step -> step instanceof GraphStep).count() > 1)
                 throw new VerificationException("GraphComputer does not support mid-traversal V()/E()", traversal);
             ///
             if (endStep instanceof CollectingBarrierStep && endStep instanceof TraversalParent) {
-                if (((TraversalParent) endStep).getLocalChildren().stream().filter(t -> !ComputerVerificationStrategy.isNotBeyondElementId(t)).findAny().isPresent())
-                    throw new VerificationException("A final CollectingBarrierStep can not process an element beyond its id: " + endStep, traversal);
+                if (((TraversalParent) endStep).getLocalChildren().stream().filter(t -> !TraversalHelper.isLocalVertex(t)).findAny().isPresent())
+                    throw new VerificationException("A final CollectingBarrierStep can not process the incident edges of a vertex: " + endStep, traversal);
             }
             ///
             if (endStep instanceof RangeGlobalStep || endStep instanceof TailGlobalStep || endStep instanceof DedupGlobalStep)
@@ -112,7 +120,9 @@ public final class ComputerVerificationStrategy extends AbstractTraversalStrateg
         }
 
         for (final Step<?, ?> step : traversal.getSteps()) {
-            if ((step instanceof ReducingBarrierStep || step instanceof SupplyingBarrierStep || step instanceof OrderGlobalStep || step instanceof RangeGlobalStep || step instanceof TailGlobalStep || step instanceof DedupGlobalStep) && (step != endStep || !(traversal.getParent() instanceof TraversalVertexProgramStep)))
+            if ((step instanceof ReducingBarrierStep || step instanceof SupplyingBarrierStep || step instanceof OrderGlobalStep
+                    || step instanceof RangeGlobalStep || step instanceof TailGlobalStep || step instanceof DedupGlobalStep)
+                    && (step != endStep || !(traversal.getParent() instanceof TraversalVertexProgramStep)))
                 throw new VerificationException("Global traversals on GraphComputer may not contain mid-traversal barriers: " + step, traversal);
 
             if (step instanceof DedupGlobalStep && !((DedupGlobalStep) step).getLocalChildren().isEmpty())
@@ -136,29 +146,16 @@ public final class ComputerVerificationStrategy extends AbstractTraversalStrateg
             if (step instanceof PathProcessor && ((PathProcessor) step).getMaxRequirement() != PathProcessor.ElementRequirement.ID)
                 throw new VerificationException("The following path processor step requires more than the element id: " + step + " requires " + ((PathProcessor) step).getMaxRequirement(), traversal);
         }
+
+        Step<?, ?> nextParentStep = traversal.getParent().asStep();
+        while (!(nextParentStep instanceof EmptyStep)) {
+            if (nextParentStep instanceof PathProcessor && ((PathProcessor) nextParentStep).getMaxRequirement() != PathProcessor.ElementRequirement.ID)
+                throw new VerificationException("The following path processor step requires more than the element id: " + nextParentStep + " requires " + ((PathProcessor) nextParentStep).getMaxRequirement(), traversal);
+            nextParentStep = nextParentStep.getNextStep();
+        }
     }
 
     public static ComputerVerificationStrategy instance() {
         return INSTANCE;
     }
-
-    /*
-     * THIS NEEDS TO GO INTO TRAVERSAL HELPER ONCE WE GET THIS ALL STRAIGHTENED OUT WITH THE INSTRUCTION SET OF GREMLIN (TODO:)
-     */
-    private static boolean isNotBeyondElementId(final Traversal.Admin<?, ?> traversal) {
-        if (traversal instanceof TokenTraversal && !((TokenTraversal) traversal).getToken().equals(T.id))
-            return false;
-        else if (traversal instanceof ElementValueTraversal)
-            return false;
-        else
-            return !traversal.getSteps().stream()
-                    .filter(step -> step instanceof VertexStep ||
-                            step instanceof EdgeVertexStep ||
-                            step instanceof PropertiesStep ||
-                            step instanceof PropertyMapStep ||
-                            (step instanceof TraversalParent &&
-                                    (((TraversalParent) step).getLocalChildren().stream().filter(t -> !ComputerVerificationStrategy.isNotBeyondElementId(t)).findAny().isPresent() ||
-                                            ((TraversalParent) step).getGlobalChildren().stream().filter(t -> !ComputerVerificationStrategy.isNotBeyondElementId(t)).findAny().isPresent())))
-                    .findAny().isPresent();
-    }
 }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/traverser/util/DefaultTraverserGeneratorFactory.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/traverser/util/DefaultTraverserGeneratorFactory.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/traverser/util/DefaultTraverserGeneratorFactory.java
index 60a22ca..6411e1e 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/traverser/util/DefaultTraverserGeneratorFactory.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/traverser/util/DefaultTraverserGeneratorFactory.java
@@ -30,6 +30,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.traverser.O_OB_S_SE_SL_Tra
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.O_TraverserGenerator;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserGeneratorFactory;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
+import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
 
 import java.util.Set;
 
@@ -49,7 +50,7 @@ public class DefaultTraverserGeneratorFactory implements TraverserGeneratorFacto
 
     @Override
     public TraverserGenerator getTraverserGenerator(final Traversal.Admin<?, ?> traversal) {
-        final Set<TraverserRequirement> requirements = traversal.getTraverserRequirements();
+        final Set<TraverserRequirement> requirements = TraversalHelper.getRootTraversal(traversal).getTraverserRequirements();
 
         if (requirements.contains(TraverserRequirement.ONE_BULK)) {
             if (O_OB_S_SE_SL_TraverserGenerator.instance().getProvidedRequirements().containsAll(requirements))

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalTest.java
index 97da482..f25425c 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalTest.java
@@ -31,7 +31,7 @@ import java.util.Set;
  */
 public class GraphTraversalTest {
 
-    private static Set<String> NO_GRAPH = new HashSet<>(Arrays.asList("asAdmin", "by", "option", "iterate", "to", "from", "profile"));
+    private static Set<String> NO_GRAPH = new HashSet<>(Arrays.asList("asAdmin", "by", "option", "iterate", "to", "from", "profile", "pageRank"));
     private static Set<String> NO_ANONYMOUS = new HashSet<>(Arrays.asList("start", "__"));
 
     @Test

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
index 8c90542..c579dcf 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyTest.java
@@ -60,7 +60,7 @@ public class ComputerVerificationStrategyTest {
         try {
             final TraversalStrategies strategies = new DefaultTraversalStrategies();
             strategies.addStrategies(ComputerVerificationStrategy.instance());
-            traversal.asAdmin().setParent(new TraversalVertexProgramStep(EmptyTraversal.instance(), EmptyTraversal.instance(), null)); // trick it
+            traversal.asAdmin().setParent(new TraversalVertexProgramStep(EmptyTraversal.instance(), EmptyTraversal.instance())); // trick it
             traversal.asAdmin().setStrategies(strategies);
             traversal.asAdmin().applyStrategies();
             fail("The strategy should not allow traversal: " + this.traversal);

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/map/GroovyPageRankTest.groovy
----------------------------------------------------------------------
diff --git a/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/map/GroovyPageRankTest.groovy b/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/map/GroovyPageRankTest.groovy
new file mode 100644
index 0000000..0efcd2d
--- /dev/null
+++ b/gremlin-groovy-test/src/main/groovy/org/apache/tinkerpop/gremlin/process/traversal/step/map/GroovyPageRankTest.groovy
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tinkerpop.gremlin.process.traversal.step.map
+
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal
+import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalScriptHelper
+import org.apache.tinkerpop.gremlin.structure.Vertex
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public abstract class GroovyPageRankTest {
+
+    public static class Traversals extends PageRankTest {
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_pageRank_order_byXpageRank_decrX_name() {
+            TraversalScriptHelper.compute("g.V.pageRank.order.by(PageRankVertexProgram.PAGE_RANK, decr).name", g)
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_pageRank_order_byXpageRank_decrX_name_limitX2X() {
+            TraversalScriptHelper.compute("g.V.pageRank.order.by(PageRankVertexProgram.PAGE_RANK, decr).name.limit(2)", g)
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-groovy-test/src/main/java/org/apache/tinkerpop/gremlin/process/GroovyProcessComputerSuite.java
----------------------------------------------------------------------
diff --git a/gremlin-groovy-test/src/main/java/org/apache/tinkerpop/gremlin/process/GroovyProcessComputerSuite.java b/gremlin-groovy-test/src/main/java/org/apache/tinkerpop/gremlin/process/GroovyProcessComputerSuite.java
index 88be667..d7c1ab3 100644
--- a/gremlin-groovy-test/src/main/java/org/apache/tinkerpop/gremlin/process/GroovyProcessComputerSuite.java
+++ b/gremlin-groovy-test/src/main/java/org/apache/tinkerpop/gremlin/process/GroovyProcessComputerSuite.java
@@ -61,6 +61,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyMaxTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyMeanTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyMinTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyOrderTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyPageRankTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyPathTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovyPropertiesTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroovySelectTest;
@@ -144,6 +145,7 @@ public class GroovyProcessComputerSuite extends ProcessComputerSuite {
             GroovyMeanTest.Traversals.class,
             GroovyMinTest.Traversals.class,
             GroovyOrderTest.Traversals.class,
+            GroovyPageRankTest.Traversals.class,
             GroovyPathTest.Traversals.class,
             GroovyPropertiesTest.Traversals.class,
             GroovySelectTest.Traversals.class,

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
index 3338acf..5295f77 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/ProcessComputerSuite.java
@@ -60,6 +60,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.MaxTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MeanTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MinTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderTest;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PageRankTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.PathTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesTest;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.SelectTest;
@@ -149,6 +150,7 @@ public class ProcessComputerSuite extends AbstractGremlinSuite {
             MinTest.Traversals.class,
             SumTest.Traversals.class,
             OrderTest.Traversals.class,
+            PageRankTest.Traversals.class,
             PathTest.Traversals.class,
             PropertiesTest.Traversals.class,
             SelectTest.Traversals.class,
@@ -225,6 +227,7 @@ public class ProcessComputerSuite extends AbstractGremlinSuite {
             SumTest.class,
             MatchTest.class,
             OrderTest.class,
+            PageRankTest.class,
             PathTest.class,
             PropertiesTest.class,
             SelectTest.class,

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
index b69c625..b6cec9f 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/OrderTest.java
@@ -41,7 +41,10 @@ import java.util.Map;
 
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 
 /**
@@ -89,7 +92,6 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
 
     @Test
     @LoadGraphWith(MODERN)
-    @IgnoreEngine(TraversalEngine.Type.COMPUTER)
     public void g_V_name_order_byXa1_b1X_byXb2_a2X() {
         final Traversal<Vertex, String> traversal = get_g_V_name_order_byXa1_b1X_byXb2_a2X();
         printTraversalForm(traversal);
@@ -305,6 +307,7 @@ public abstract class OrderTest extends AbstractGremlinProcessTest {
     }
 
     @Test
+    @IgnoreEngine(TraversalEngine.Type.COMPUTER) // FOLD NEEDS TO BE SEEDED
     @LoadGraphWith(MODERN)
     public void g_V_hasLabelXpersonX_fold_orderXlocalX_byXageX() {
         final Traversal<Vertex, List<Vertex>> traversal = get_g_V_hasLabelXpersonX_fold_orderXlocalX_byXageX();

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PageRankTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PageRankTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PageRankTest.java
new file mode 100644
index 0000000..b28d6d3
--- /dev/null
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PageRankTest.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tinkerpop.gremlin.process.traversal.step.map;
+
+import org.apache.tinkerpop.gremlin.LoadGraphWith;
+import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
+import org.apache.tinkerpop.gremlin.process.GremlinProcessRunner;
+import org.apache.tinkerpop.gremlin.process.computer.ranking.pagerank.PageRankVertexProgram;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+
+import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+@RunWith(GremlinProcessRunner.class)
+public abstract class PageRankTest extends AbstractGremlinProcessTest {
+
+    public abstract Traversal<Vertex, String> get_g_V_pageRank_order_byXpageRank_decrX_name();
+
+    public abstract Traversal<Vertex, String> get_g_V_pageRank_order_byXpageRank_decrX_name_limitX2X();
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_pageRank_order_byXpageRank_decrX_name() {
+        final Traversal<Vertex, String> traversal = get_g_V_pageRank_order_byXpageRank_decrX_name();
+        printTraversalForm(traversal);
+        final List<String> names = traversal.toList();
+        assertEquals(6, names.size());
+        assertEquals("lop", names.get(0));
+        assertEquals("ripple", names.get(1));
+        assertTrue(names.get(2).equals("josh") || names.get(2).equals("vadas"));
+        assertTrue(names.get(3).equals("josh") || names.get(3).equals("vadas"));
+        assertTrue(names.get(4).equals("marko") || names.get(4).equals("peter"));
+        assertTrue(names.get(5).equals("marko") || names.get(5).equals("peter"));
+    }
+
+    @Test
+    @LoadGraphWith(MODERN)
+    public void g_V_pageRank_order_byXpageRank_decrX_name_limitX2X() {
+        final Traversal<Vertex, String> traversal = get_g_V_pageRank_order_byXpageRank_decrX_name_limitX2X();
+        printTraversalForm(traversal);
+        final List<String> names = traversal.toList();
+        assertEquals(2, names.size());
+        assertEquals("lop", names.get(0));
+        assertEquals("ripple", names.get(1));
+    }
+
+    public static class Traversals extends PageRankTest {
+        @Override
+        public Traversal<Vertex, String> get_g_V_pageRank_order_byXpageRank_decrX_name() {
+            return g.V().pageRank().order().by(PageRankVertexProgram.PAGE_RANK, Order.decr).values("name");
+        }
+
+        @Override
+        public Traversal<Vertex, String> get_g_V_pageRank_order_byXpageRank_decrX_name_limitX2X() {
+            return g.V().pageRank().order().by(PageRankVertexProgram.PAGE_RANK, Order.decr).<String>values("name").limit(2);
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyProcessTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyProcessTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyProcessTest.java
index f6ded69..2de89db 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyProcessTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/verification/ComputerVerificationStrategyProcessTest.java
@@ -20,13 +20,15 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.verification;
 
 import org.apache.tinkerpop.gremlin.LoadGraphWith;
 import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.junit.Test;
 
 import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
-import static org.apache.tinkerpop.gremlin.process.traversal.NumberHelper.mul;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.max;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.min;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.sum;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -76,24 +78,6 @@ public abstract class ComputerVerificationStrategyProcessTest extends AbstractGr
                 final GraphTraversal t = g.V().values("age").union(max(), min(), sum()).iterate();
                 fail("Nested global traversals should not be allowed to contain barriers (COMPUTER): " + t);
             } catch (IllegalStateException e) {
-               assertTrue(true);
-            }
-        }
-
-        @Test
-        @LoadGraphWith(MODERN)
-        public void shouldNotAllowMidTraversalBarriersOnComputer() {
-            try {
-                final GraphTraversal t = g.V().count().sum().iterate();
-                fail("Mid-traversal barrier steps are not allowed (COMPUTER): " + t);
-            } catch (IllegalStateException e) {
-                assertTrue(true);
-            }
-
-            try {
-                final GraphTraversal t = g.V().count().sum().map(x -> mul(x.get(), 19)).iterate();
-                fail("Mid-traversal barrier steps are not allowed (COMPUTER): " + t);
-            } catch (IllegalStateException e) {
                 assertTrue(true);
             }
         }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/computer/TinkerMessenger.java
----------------------------------------------------------------------
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/computer/TinkerMessenger.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/computer/TinkerMessenger.java
index 3298aff..7ea2b8b 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/computer/TinkerMessenger.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/computer/TinkerMessenger.java
@@ -104,7 +104,7 @@ public final class TinkerMessenger<M> implements Messenger<M> {
     ///////////
 
     private static <T extends Traversal.Admin<Vertex, Edge>> T setVertexStart(final Traversal.Admin<Vertex, Edge> incidentTraversal, final Vertex vertex) {
-        incidentTraversal.addStep(0, new StartStep<>(incidentTraversal, vertex));
+        incidentTraversal.addStart(incidentTraversal.getTraverserGenerator().generate(vertex,incidentTraversal.getStartStep(),1l));
         return (T) incidentTraversal;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/TinkerGraphNoStrategyComputerProvider.java
----------------------------------------------------------------------
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/TinkerGraphNoStrategyComputerProvider.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/TinkerGraphNoStrategyComputerProvider.java
index e20f035..227ada2 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/TinkerGraphNoStrategyComputerProvider.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/TinkerGraphNoStrategyComputerProvider.java
@@ -23,6 +23,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ProfileStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RangeByIsCountStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ComputerVerificationStrategy;
 import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
@@ -38,6 +39,7 @@ import java.util.stream.Collectors;
 public class TinkerGraphNoStrategyComputerProvider extends TinkerGraphComputerProvider {
 
     private static final HashSet<Class<? extends TraversalStrategy>> REQUIRED_STRATEGIES = new HashSet<>(Arrays.asList(
+            RangeByIsCountStrategy.class,
             ComputerVerificationStrategy.class,
             ProfileStrategy.class,
             ConnectiveStrategy.class));

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a4cf1514/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
----------------------------------------------------------------------
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
index 773a5ae..88a52f6 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
@@ -19,13 +19,16 @@
 package org.apache.tinkerpop.gremlin.tinkergraph.structure;
 
 import org.apache.tinkerpop.gremlin.process.computer.bulkloading.BulkLoaderVertexProgram;
+import org.apache.tinkerpop.gremlin.process.computer.ranking.pagerank.PageRankVertexProgram;
 import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
 import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.process.traversal.Scope;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.structure.Column;
 import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
@@ -39,7 +42,9 @@ import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.function.Supplier;
 
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.as;
@@ -49,9 +54,11 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.count;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.fold;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.groupCount;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.identity;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.in;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.outE;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.properties;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.select;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.union;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.valueMap;
@@ -69,7 +76,9 @@ public class TinkerGraphPlayTest {
         Graph graph = TinkerFactory.createModern();
         GraphTraversalSource g = graph.traversal().withComputer(); //GraphTraversalSource.computer());
         //System.out.println(g.V().outE("knows").identity().inV().count().is(P.eq(5)).explain());
-        System.out.println(g.withBulk(false).withSack(1, Operator.sum).V().out().barrier().sack().toList());
+        //System.out.println(g.V().hasLabel("person").fold().order(Scope.local).by("age").toList());
+        System.out.println(g.V().pageRank().order().by(PageRankVertexProgram.PAGE_RANK, Order.decr).values("name").toList());
+        //System.out.println(g.V().pageRank().order().by(PageRankVertexProgram.PAGE_RANK).valueMap().toList());
 
     }