Track compile and execution times in BexMetrics and integrate meaningful node checks in BexCompiler

Author: piotr-blue

src/main/java/blue/bex/api/BexEngine.java

@@ -43,6 +43,8 @@ public BexCompiledProgram compile(BexProgramSource source) {
     }
 
     private BexCompiledProgram compile(BexProgramSource source, BexMetrics metrics) {
+        long start = System.nanoTime();
+        try {
         BexCompiledProgramKey key = key(source);
         BexCompiledProgram cached = cache.get(key);
         if (cached != null) {
@@ -53,6 +55,9 @@ private BexCompiledProgram compile(BexProgramSource source, BexMetrics metrics)
         BexCompiledProgram program = new BexCompiler(metrics).compile(source);
         cache.put(key, program);
         return program;
+        } finally {
+            metrics.addCompileNanos(System.nanoTime() - start);
+        }
     }
 
     public BexExecutionResult execute(BexCompiledProgram program, BexExecutionContext context) {
@@ -63,8 +68,15 @@ public BexExecutionResult execute(BexCompiledProgram program, BexExecutionContex
     }
 
     private BexExecutionResult execute(BexCompiledProgram program, BexExecutionContext context, BexMetrics metrics) {
+        long start = System.nanoTime();
         BexRuntime runtime = new BexRuntime(program, context, gasSchedule, metrics, pointerCache);
-        return runtime.execute();
+        BexExecutionResult result = runtime.execute();
+        metrics.addExecuteNanos(System.nanoTime() - start);
+        return new BexExecutionResult(result.value(),
+                result.changeset(),
+                result.events(),
+                result.gasUsed(),
+                metrics);
     }
 
     public BexExecutionResult compileAndExecute(BexProgramSource source, BexExecutionContext context) {

src/main/java/blue/bex/compile/BexCompiler.java

@@ -49,7 +49,8 @@ public BexCompiledProgram compile(blue.bex.api.BexProgramSource source) {
             compiledFunctions.put(name, compileFunction(name, functionNodes.get(name)));
         }
 
-        String entryName = source.entry().orElse(text(prop(step, "entry")));
+        FrozenNode stepExpr = meaningful(prop(step, "expr"));
+        String entryName = source.entry().orElse(text(meaningful(prop(step, "entry"))));
         BexCompiledProgram.CompiledFunction root;
         int rootFrameSize = 0;
         if (entryName != null && !entryName.isEmpty()) {
@@ -62,14 +63,14 @@ public BexCompiledProgram compile(blue.bex.api.BexProgramSource source) {
                             new ReturnStatement(sourceExpr("$root", "/entry/$call", "$call",
                                     new CallExpr(entryName, new String[0], new CompiledExpression[0]))))),
                     null, 0);
-        } else if (prop(step, "expr") != null) {
+        } else if (stepExpr != null) {
             currentFunction = "$root";
             root = new BexCompiledProgram.CompiledFunction("$root", Collections.<String>emptyList(),
-                    Collections.<CompiledStatement>emptyList(), compileExpr(prop(step, "expr"), new CompileScope(), "/expr"), 0);
+                    Collections.<CompiledStatement>emptyList(), compileExpr(stepExpr, new CompileScope(), "/expr"), 0);
         } else {
             CompileScope scope = new CompileScope();
             currentFunction = "$root";
-            List<CompiledStatement> statements = compileStatements(prop(step, "do"), scope, "/do");
+            List<CompiledStatement> statements = compileStatements(meaningful(prop(step, "do")), scope, "/do");
             rootFrameSize = scope.frameSize();
             root = new BexCompiledProgram.CompiledFunction("$root", Collections.<String>emptyList(), statements, null, rootFrameSize);
         }
@@ -90,9 +91,10 @@ private BexCompiledProgram.CompiledFunction compileFunction(String name, FrozenN
                 scope.declareOrGetSlot(arg);
             }
         }
-        CompiledExpression expression = prop(functionNode, "expr") != null ? compileExpr(prop(functionNode, "expr"), scope, "/functions/" + escape(name) + "/expr") : null;
+        FrozenNode functionExpr = meaningful(prop(functionNode, "expr"));
+        CompiledExpression expression = functionExpr != null ? compileExpr(functionExpr, scope, "/functions/" + escape(name) + "/expr") : null;
         List<CompiledStatement> statements = expression == null
-                ? compileStatements(prop(functionNode, "do"), scope, "/functions/" + escape(name) + "/do")
+                ? compileStatements(meaningful(prop(functionNode, "do")), scope, "/functions/" + escape(name) + "/do")
                 : Collections.<CompiledStatement>emptyList();
         currentFunction = previousFunction;
         return new BexCompiledProgram.CompiledFunction(name, Collections.unmodifiableList(args),
@@ -467,6 +469,16 @@ private FrozenNode prop(FrozenNode node, String key) {
         return null;
     }
 
+    private FrozenNode meaningful(FrozenNode node) {
+        if (node == null) {
+            return null;
+        }
+        boolean hasPayload = node.getValue() != null
+                || (node.getItems() != null && !node.getItems().isEmpty())
+                || (node.getProperties() != null && !node.getProperties().isEmpty());
+        return hasPayload ? node : null;
+    }
+
     private FrozenNode required(FrozenNode node, String label) {
         if (node == null) {
             throw new BexException("Missing required field: " + label);

src/main/java/blue/bex/result/BexMetrics.java

@@ -41,6 +41,8 @@ public final class BexMetrics {
     private long sizeEstimateCacheMisses;
     private long frozenWriterNodeFallbacks;
     private long frozenWriterChildNodeRoundTrips;
+    private long compileNanos;
+    private long executeNanos;
 
     public BexMetrics copy() {
         BexMetrics copy = new BexMetrics();
@@ -77,6 +79,8 @@ public BexMetrics copy() {
         copy.sizeEstimateCacheMisses = sizeEstimateCacheMisses;
         copy.frozenWriterNodeFallbacks = frozenWriterNodeFallbacks;
         copy.frozenWriterChildNodeRoundTrips = frozenWriterChildNodeRoundTrips;
+        copy.compileNanos = compileNanos;
+        copy.executeNanos = executeNanos;
         return copy;
     }
 
@@ -113,6 +117,8 @@ public BexMetrics copy() {
     public void incrementSizeEstimateCacheMisses() { sizeEstimateCacheMisses++; }
     public void incrementFrozenWriterNodeFallbacks() { frozenWriterNodeFallbacks++; }
     public void incrementFrozenWriterChildNodeRoundTrips() { frozenWriterChildNodeRoundTrips++; }
+    public void addCompileNanos(long nanos) { compileNanos += Math.max(0L, nanos); }
+    public void addExecuteNanos(long nanos) { executeNanos += Math.max(0L, nanos); }
 
     public long compiledExecutions() { return compiledExecutions; }
     public long compileCacheHits() { return compileCacheHits; }
@@ -147,4 +153,6 @@ public BexMetrics copy() {
     public long sizeEstimateCacheMisses() { return sizeEstimateCacheMisses; }
     public long frozenWriterNodeFallbacks() { return frozenWriterNodeFallbacks; }
     public long frozenWriterChildNodeRoundTrips() { return frozenWriterChildNodeRoundTrips; }
+    public long compileNanos() { return compileNanos; }
+    public long executeNanos() { return executeNanos; }
 }