checkpoint save

devdocs/sketches/opsynthesis.md

@@ -0,0 +1,37 @@
+# Op Synthesis
+
+This is a sketch of API boundaries and types for the NB driver API revamp.
+
+```puml
+participant "Workload\nModel" as workload
+participant "Activity\nType" as adapter
+participant "Op\nType" as optype
+participant "Op\nSource" as opsource
+participant "Standard\nActivity" as activity
+participant "Standard\nAction" as action
+participant "Native\nDriver" as native
+participant "Target\nSystem" as target
+
+activity -> workload: getOpTemplate
+activity <- workload: <OpTemplate>
+
+activity -> workload: getOp
+workload -> activity
+
+activity -> adapter
+
+activity -> adapter: getOpSource
+activate adapter
+activity <- adapter: <OpSource>
+deactivate adapter
+
+activity -> opsource: getOp
+
+native -> target: execute operation
+activate target
+
+
+native <- target:
+deactivate target
+
+```

devdocs/sketches/opsynthesis.puml

@@ -0,0 +1,65 @@
+@startuml
+autoactivate on
+participant "Workload\nModel" as workload
+participant "Driver\nAdapter" as adapter #ff0
+participant "Op\nType" as optype  #ff0
+
+participant "Standard\nActivity" as activity #0fa
+participant "Op\nSource" as opsource #0fa
+participant "Standard\nAction" as action #0fa
+
+participant "Native\nDriver" as native #ff00ff
+participant "Target\nSystem" as target #ff00ff
+
+=== during initialization ===
+activity -> adapter: getOpMapperFunc()
+return <OpMapperFunc>
+activity -> workload: getWorkloadTemplate()
+return <OpTemplate>
+
+
+note over activity
+ The activity composes an OpSource
+ function from the template data
+ and the op mapping logic
+end note
+
+activity -> opsource ** : compose function\n<OpSource<OpType>>
+
+activity -> action ** : create worker\nwith <OpSource<OpType>>
+
+=== during cycling ===
+
+action -> opsource: getOp()
+
+opsource -> optype ** : create
+return <op>
+
+return <op:OpType>
+
+action -> action: run(op)
+
+
+native -> target: execute operation
+return <result>
+
+
+return result
+
+
+'activity -> workload: getOpTemplate
+'activity <- workload: <OpTemplate>
+
+'activity -> workload: getOp
+'workload -> activity
+'
+'activity -> adapter
+'
+'activity -> adapter: getOpSource
+'activate adapter
+'activity <- adapter: <OpSource>
+'deactivate adapter
+'
+'activity -> opsource: getOp
+'
+@end

driver-direct/src/main/java/io/nosqlbench/driver/direct/DirectAction.java

@@ -1,25 +0,0 @@
-package io.nosqlbench.driver.direct;
-
-import io.nosqlbench.engine.api.activityapi.core.SyncAction;
-import io.nosqlbench.engine.api.activityimpl.OpDispenser;
-
-public class DirectAction implements SyncAction {
-    private final int slot;
-    private final DirectActivity activity;
-
-    public DirectAction(int slot, DirectActivity activity) {
-        this.slot = slot;
-        this.activity = activity;
-    }
-
-
-    @Override
-    public int runCycle(long cycle) {
-
-        OpDispenser<? extends Runnable> dispenser = activity.getSequencer().apply(cycle);
-        Runnable apply = dispenser.apply(cycle);
-
-
-        return SyncAction.super.runCycle(cycle);
-    }
-}

driver-direct/src/main/java/io/nosqlbench/driver/direct/DirectActivityType.java

@@ -3,9 +3,15 @@ package io.nosqlbench.driver.direct;
 import io.nosqlbench.engine.api.activityapi.core.Action;
 import io.nosqlbench.engine.api.activityapi.core.ActionDispenser;
 import io.nosqlbench.engine.api.activityapi.core.ActivityType;
+import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
 import io.nosqlbench.engine.api.activityimpl.ActivityDef;
+import io.nosqlbench.engine.api.activityimpl.OpDispenser;
+import io.nosqlbench.engine.api.activityimpl.uniform.StandardAction;
+import io.nosqlbench.engine.api.activityimpl.uniform.StandardActivity;
 import io.nosqlbench.nb.annotations.Service;
 
+import java.util.function.Function;
+
 /**
  * This activity type driver allows you to dynamically map any available
  * Java API which is exposed to the NoSQLBench runtime, executing methods
@@ -16,7 +22,7 @@ import io.nosqlbench.nb.annotations.Service;
  * object scoping.
  */
 @Service(value = ActivityType.class,selector = "direct")
-public class DirectActivityType implements ActivityType<DirectActivity> {
+public class DirectActivityType extends StandardActivity<DirectCall> {
 
     @Override
     public DirectActivity getActivity(ActivityDef activityDef) {
@@ -28,6 +34,11 @@ public class DirectActivityType implements ActivityType<DirectActivity> {
         return new DirectActionDispenser(activity);
     }
 
+    @Override
+    protected Function<OpTemplate, OpDispenser<DirectCall>> getOpMapperFunction() {
+        return null;
+    }
+
     private static class DirectActionDispenser implements ActionDispenser {
 
         private final DirectActivity activity;
@@ -38,7 +49,7 @@ public class DirectActivityType implements ActivityType<DirectActivity> {
 
         @Override
         public Action getAction(int slot) {
-            return new DirectAction(slot, activity);
+            return new StandardAction<DirectActivity,DirectCall>(slot, getOpSource());
         }
     }
 }

driver-grpc/src/main/java/io/nosqlbench/driver/grpc/GrpcAction.java

@@ -1,17 +1,17 @@
 package io.nosqlbench.driver.grpc;
 
-import com.codahale.metrics.Timer;
 import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
+import io.nosqlbench.engine.api.activityapi.planning.OpSource;
 import io.nosqlbench.engine.api.activityimpl.OpDispenser;
 import io.nosqlbench.engine.api.activityimpl.uniform.StandardAction;
 
-public class GrpcAction extends StandardAction {
+public class GrpcAction extends StandardAction<GrpcActivity,GrpcOp> {
 
     private final int slot;
     private final GrpcActivity activity;
-    private OpSequence<OpDispenser<GrpcOp>> sequencer;
+    private OpSource<GrpcOp> sequencer;
 
-    public GrpcAction(int slot, GrpcActivity activity, OpSequence opsource) {
+    public GrpcAction(int slot, GrpcActivity activity, OpSequence<OpDispenser<GrpcOp>> opsource) {
         super(activity, opsource);
         this.slot = slot;
         this.activity = activity;
@@ -19,28 +19,7 @@ public class GrpcAction extends StandardAction {
 
     @Override
     public void init() {
-        this.sequencer = activity.getSequencer();
+        this.sequencer = activity.getOpsource();
     }
 
-
-    @Override
-    public int runCycle(long cycle) {
-
-        GrpcOp op = null;
-        try (Timer.Context ctx = activity.getInstrumentation().getOrCreateBindTimer().time()) {
-
-            // Get the template instance from the sequence
-            OpDispenser<GrpcOp> opDispenser = sequencer.apply(cycle);
-
-            // Get an executable op from the template instance
-            op = opDispenser.apply(cycle);
-        }
-
-        int tries = activity.getMaxTries();
-
-
-        op.run();
-
-        return 0;
-    }
 }

engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/planning/OpSource.java

@@ -3,7 +3,7 @@ package io.nosqlbench.engine.api.activityapi.planning;
 import java.util.function.LongFunction;
 
 /**
- * An OpSource provides an Op when given an ordinal.
+ * An OpSource provides an Op for a given long value.
  * OpSources are expected to be deterministic with respect to inputs.
  *
  * @param <T>

engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardAction.java

@@ -4,9 +4,8 @@ import com.codahale.metrics.Timer;
 import io.nosqlbench.engine.api.activityapi.core.ActivityDefObserver;
 import io.nosqlbench.engine.api.activityapi.core.SyncAction;
 import io.nosqlbench.engine.api.activityapi.errorhandling.modular.ErrorDetail;
-import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
+import io.nosqlbench.engine.api.activityapi.planning.OpSource;
 import io.nosqlbench.engine.api.activityimpl.ActivityDef;
-import io.nosqlbench.engine.api.activityimpl.OpDispenser;
 
 import java.util.concurrent.TimeUnit;
 
@@ -23,9 +22,9 @@ import java.util.concurrent.TimeUnit;
 public class StandardAction<A extends StandardActivity<O>, O extends Runnable> implements SyncAction, ActivityDefObserver {
 
     private final A activity;
-    private final OpSequence<OpDispenser<O>> opsource;
+    private final OpSource<O> opsource;
 
-    public StandardAction(A activity, OpSequence<OpDispenser<O>> opsource) {
+    public StandardAction(A activity, OpSource<O> opsource) {
         this.activity = activity;
         this.opsource = opsource;
     }
@@ -35,8 +34,7 @@ public class StandardAction<A extends StandardActivity<O>, O extends Runnable> i
 
         O op = null;
         try (Timer.Context ct = activity.getInstrumentation().getOrCreateInputTimer().time()) {
-            OpDispenser<O> ready = opsource.apply(cycle);
-            op = ready.apply(cycle);
+            op = opsource.apply(cycle);
         }
 
         int tries = 0;

engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java

@@ -1,6 +1,6 @@
 package io.nosqlbench.engine.api.activityimpl.uniform;
 
-import io.nosqlbench.engine.api.activityapi.planning.OpSequence;
+import io.nosqlbench.engine.api.activityapi.planning.OpSource;
 import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
 import io.nosqlbench.engine.api.activityimpl.ActivityDef;
 import io.nosqlbench.engine.api.activityimpl.DiagRunnableOpMapper;
@@ -18,17 +18,17 @@ import java.util.function.Function;
  */
 public abstract class StandardActivity<O extends Runnable> extends SimpleActivity {
 
-    private OpSequence<OpDispenser<O>> sequencer;
+    private OpSource<O> opsource;
 
     public StandardActivity(ActivityDef activityDef) {
         super(activityDef);
     }
 
-    public synchronized OpSequence<OpDispenser<O>> getSequencer() {
-        if (this.sequencer == null) {
+    public synchronized OpSource<O> getOpsource() {
+        if (this.opsource == null) {
             Function<OpTemplate, OpDispenser<O>> dispenserMapper = getOpMapperFunction();
         }
-        return sequencer;
+        return opsource;
     }
 
     protected abstract Function<OpTemplate, OpDispenser<O>> getOpMapperFunction();