Save + restore context during evaluate

Reverted changes not reqd anymore

Author: uw4

src/main/java/com/dashjoin/jsonata/Functions.java

@@ -1561,10 +1561,9 @@ public static List hofFuncArgs(Object func, Object arg1, Object arg2, Object arg
      */
     public static Object funcApply(Object func, List funcArgs) throws Throwable {
         Object res;
-        if (isLambda(func)) {
-            Jsonata.EvalContext ctx = Jsonata.evalContext.get();
-            res = ctx.instance.apply(func, funcArgs, null, ctx.environment);
-        } else
+        if (isLambda(func))
+            res = Jsonata.current.get().apply(func, funcArgs, null, Jsonata.current.get().environment);
+        else
             res = ((JFunction)func).call(null, funcArgs);
         return res;
     }
@@ -2376,8 +2375,7 @@ public static Object functionEval(String expr, Object focus) {
         if(expr == null) {
             return null;
         }
-        Jsonata.EvalContext ctx = Jsonata.evalContext.get();
-        Object input = ctx.input;
+        Object input = Jsonata.current.get().input; // =  this.input;
         if(focus != null) {
             input = focus;
             // if the input is a JSON array, then wrap it in a singleton sequence so it gets treated as a single input
@@ -2388,7 +2386,7 @@ public static Object functionEval(String expr, Object focus) {
         }
 
         Jsonata ast;
-        Jsonata.Frame env = ctx.environment;
+        Jsonata.Frame env = Jsonata.current.get().environment;
         try {
             ast = jsonata(expr);
         } catch(Throwable err) {
@@ -2399,7 +2397,7 @@ public static Object functionEval(String expr, Object focus) {
         }
         Object result = null;
         try {
-            result = ctx.instance.evaluate(ast.ast, input, env);
+            result = Jsonata.current.get().evaluate(ast.ast, input, env);
         } catch(Throwable err) {
             // error evaluating the expression passed to $eval
             //populateMessage(err);
@@ -2414,15 +2412,15 @@ public static Object functionEval(String expr, Object focus) {
     //      return datetime.fromMillis(timestamp.getTime(), picture, timezone);
     //  }, "<s?s?:s>"));
     public static String now(String picture, String timezone) {
-        long t = Jsonata.evalContext.get().timestamp;
+        long t = Jsonata.current.get().timestamp;
         return dateTimeFromMillis(t, picture, timezone);
     }
 
     //  environment.bind("millis", defineFunction(function() {
     //      return timestamp.getTime();
     //  }, "<:n>"));
     public static long millis() {
-        long t = Jsonata.evalContext.get().timestamp;
+        long t = Jsonata.current.get().timestamp;
         return t;
     }
 }

src/main/java/com/dashjoin/jsonata/Jsonata.java

@@ -127,22 +127,29 @@ public void setEvaluateExitCallback(ExitCallback cb) {
      * @returns {*} Evaluated input data
      */
     Object evaluate(Symbol expr, Object input, Frame environment) {
-        return _evaluate(expr, input, environment);
+        // Thread safety:
+        // Make sure each evaluate is executed on an instance per thread
+        Jsonata _this = getPerThreadInstance();
+        // Save and restore the evaluation context so that nested
+        // evaluations (e.g. $eval()) see the correct context.        
+        Object _input = _this.input;
+        Frame _environment = _this.environment;
+        try {
+          return _this._evaluate(expr, input, environment);
+        } finally {
+            _this.input = _input;
+            _this.environment = _environment;
+        }
     }
 
     Object _evaluate(Symbol expr, Object input, Frame environment) {
         Object result = null;
 
-        // Save and restore the evaluation context so that nested
-        // evaluations (e.g. $eval()) see the correct context.
-        // All mutable per-evaluation state lives on EvalContext, not on this instance.
-        EvalContext ctx = evalContext.get();
-        Object savedInput = ctx.input;
-        Frame savedEnvironment = ctx.environment;
-        ctx.input = input;
-        ctx.environment = environment;
+        // Store the current input + environment
+        // This is required by Functions.functionEval for current $eval() input context
+        this.input = input;
+        this.environment = environment;
 
-        try {
             if (parser.dbg) System.out.println("eval expr="+expr+" type="+expr.type);//+" input="+input);
 
             var entryCallback = environment.lookup("__evaluate_entry");
@@ -239,10 +246,6 @@ Object _evaluate(Symbol expr, Object input, Frame environment) {
             }
 
             return result;
-        } finally {
-            ctx.input = savedInput;
-            ctx.environment = savedEnvironment;
-        }
     }
 
     /**
@@ -1556,34 +1559,29 @@ boolean isFunctionLike(Object o) {
         return Utils.isFunction(o) || Functions.isLambda(o) || (o instanceof Pattern);
     }
 
+    final static ThreadLocal<Jsonata> current = new ThreadLocal<>();
+
     /**
-     * Mutable evaluation context, stored on a static ThreadLocal.
-     * Holds all per-evaluation state that was previously stored as mutable fields
-     * on the Jsonata instance. This allows the Jsonata instance itself to remain
-     * immutable after construction, making it freely shareable across threads
-     * with no cloning needed.
+     * Returns a per thread instance of this parsed expression.
+     * 
+     * @return
      */
-    static final class EvalContext {
-        Object input;
-        Frame environment;
-        long timestamp;
-        final Jsonata instance;
-
-        EvalContext(Jsonata instance) {
-            this.instance = instance;
+    Jsonata getPerThreadInstance() {
+        Jsonata threadInst = current.get();
+        // Fast path
+        if (threadInst!=null)
+            return threadInst;
+
+        synchronized(this) {
+            threadInst = current.get();
+            if (threadInst==null) {
+                threadInst = new Jsonata(this);
+                current.set(threadInst);
+            }
+            return threadInst;
         }
     }
 
-    /**
-     * Thread-local evaluation context. Set at the entry point of evaluate()
-     * and restored after evaluation completes. Read by Functions.java for
-     * $eval(), $now(), $millis(), and funcApply().
-     *
-     * This is the ONLY ThreadLocal needed. No per-instance ThreadLocals,
-     * no cloning, no mutable state on the Jsonata instance during evaluation.
-     */
-    static final ThreadLocal<EvalContext> evalContext = new ThreadLocal<>();
-
      /**
       * Evaluate Object against input data
       * @param {Object} expr - JSONata expression
@@ -1594,6 +1592,8 @@ static final class EvalContext {
      /* async */ Object evaluateFunction(Symbol expr, Object input, Frame environment, Object applytoContext) {
          Object result = null;
 
+         // this.current is set by getPerThreadInstance() at this point
+ 
          // create the procedure
          // can"t assume that expr.procedure is a lambda type directly
          // could be an expression that evaluates to a Object (e.g. variable reference, parens expr etc.
@@ -2484,6 +2484,8 @@ Exception populateMessage(Exception err) {
     List<Exception> errors;
     Frame environment;
     Symbol ast;
+    long timestamp;
+    Object input;
 
     static {
         staticFrame = new Frame(null);
@@ -2516,6 +2518,8 @@ public static Jsonata jsonata(String expression) {
         }
         environment = createFrame(staticFrame);
 
+        timestamp = System.currentTimeMillis(); // will be overridden on each call to evalute()
+
         // Note: now and millis are implemented in Functions
         //  environment.bind("now", defineFunction(function(picture, timezone) {
         //      return datetime.fromMillis(timestamp.getTime(), picture, timezone);
@@ -2531,8 +2535,21 @@ public static Jsonata jsonata(String expression) {
         //      jsonata.RegexEngine = RegExp;
         //  }
 
+        // Set instance for this thread
+        current.set(this);
     }
 
+    /**
+     * Creates a clone of the given Jsonata instance.
+     * Package-private copy constructor used to create per thread instances.
+     * 
+     * @param other
+     */
+    Jsonata(Jsonata other) {
+        this.ast = other.ast;
+        this.environment = other.environment;
+        this.timestamp = other.timestamp;
+    }
 
     /**
      * Flag: validate input objects to comply with JSON types
@@ -2574,10 +2591,13 @@ public Object evaluate(Object input, Frame bindings) { // FIXME:, callback) {
         } else {
             exec_env = environment;
         }
+        // put the input document into the environment as the root object
         exec_env.bind("$", input);
 
-        // Timestamp for $now() and $millis() — captured once per evaluation
-        long ts = System.currentTimeMillis();
+        // capture the timestamp and put it in the execution environment
+        // the $now() and $millis() functions will return this value - whenever it is called
+        timestamp = System.currentTimeMillis();
+        //exec_env.timestamp = timestamp;
 
         // if the input is a JSON array, then wrap it in a singleton sequence so it gets treated as a single input
         if((input instanceof List) && !Utils.isSequence(input)) {
@@ -2588,24 +2608,18 @@ public Object evaluate(Object input, Frame bindings) { // FIXME:, callback) {
         if (validateInput)
             Functions.validateInput(input);
 
-        EvalContext prev = evalContext.get();
-        EvalContext ctx = new EvalContext(this);
-        ctx.input = input;
-        ctx.environment = exec_env;
-        ctx.timestamp = ts;
-        evalContext.set(ctx);
-
         Object it;
         try {
             it = /* await */ evaluate(ast, input, exec_env);
+        //  if (typeof callback === "function") {
+        //      callback(null, it);
+        //  }
             it = Utils.convertNulls(it);
             return it;
         } catch (Exception err) {
             // insert error message into structure
             populateMessage(err); // possible side-effects on `err`
             throw err;
-        } finally {
-            evalContext.set(prev);
         }
     }